另一个答案提到了Flask-Rauth，但没有详细说明如何使用它。有一些Google特有的陷阱，但我最终实现了它，它运行得很好。我将它与Flask-Login集成，这样我就可以用@login_required这样有用的糖来装饰我的视图。
我希望能够支持多个OAuth2提供程序，因此部分代码是通用的，并基于Miguel Grinberg关于通过Facebook和Twitter here支持OAuth2的精彩帖子。
首先，将来自Google的特定Google身份验证信息添加到您的应用配置中：

GOOGLE_LOGIN_CLIENT_ID = "<your-id-ending-with>.apps.googleusercontent.com"
GOOGLE_LOGIN_CLIENT_SECRET = "<your-secret>"

OAUTH_CREDENTIALS={
        'google': {
            'id': GOOGLE_LOGIN_CLIENT_ID,
            'secret': GOOGLE_LOGIN_CLIENT_SECRET
        }
}

当你创建你的应用程序时（在我的例子中，模块是__init__.py）：

app = Flask(__name__)
app.config.from_object('config')

在您的应用模块中，创建auth.py：

from flask import url_for, current_app, redirect, request
from rauth import OAuth2Service

import json, urllib2

class OAuthSignIn(object):
    providers = None

    def __init__(self, provider_name):
        self.provider_name = provider_name
        credentials = current_app.config['OAUTH_CREDENTIALS'][provider_name]
        self.consumer_id = credentials['id']
        self.consumer_secret = credentials['secret']

    def authorize(self):
        pass

    def callback(self):
        pass

    def get_callback_url(self):
        return url_for('oauth_callback', provider=self.provider_name,
                        _external=True)

    @classmethod
    def get_provider(self, provider_name):
        if self.providers is None:
            self.providers={}
            for provider_class in self.__subclasses__():
                provider = provider_class()
                self.providers[provider.provider_name] = provider
        return self.providers[provider_name]

class GoogleSignIn(OAuthSignIn):
    def __init__(self):
        super(GoogleSignIn, self).__init__('google')
        googleinfo = urllib2.urlopen('https://accounts.google.com/.well-known/openid-configuration')
        google_params = json.load(googleinfo)
        self.service = OAuth2Service(
                name='google',
                client_id=self.consumer_id,
                client_secret=self.consumer_secret,
                authorize_url=google_params.get('authorization_endpoint'),
                base_url=google_params.get('userinfo_endpoint'),
                access_token_url=google_params.get('token_endpoint')
        )

    def authorize(self):
        return redirect(self.service.get_authorize_url(
            scope='email',
            response_type='code',
            redirect_uri=self.get_callback_url())
            )

    def callback(self):
        if 'code' not in request.args:
            return None, None, None
        oauth_session = self.service.get_auth_session(
                data={'code': request.args['code'],
                      'grant_type': 'authorization_code',
                      'redirect_uri': self.get_callback_url()
                     },
                decoder = json.loads
        )
        me = oauth_session.get('').json()
        return (me['name'],
                me['email'])

这将创建一个可以子类化的泛型OAuthSignIn类。（JSON格式here）。这些信息可能会发生变化，因此这种方法将确保它始终是最新的。这样做的一个限制是，如果在初始化Flask应用程序时服务器上没有Internet连接（导入的模块），它将不会被正确示例化。这几乎不会是一个问题，但是在配置数据库中存储最后已知的值以应对这种可能性是一个好主意。
最后，该类在callback()函数中返回一个name, email元组。Google实际上返回了更多信息，包括Google+个人资料（如果有）。检查oauth_session.get('').json()返回的字典可以看到所有信息。如果在authorize()函数中扩展了作用域，（对于我的应用程序，email就足够了），你可以通过Google API访问更多的信息。
接下来，编写视图，将所有内容联系在一起：

from flask.ext.login import login_user, logout_user, current_user, login_required

@app.route('/authorize/<provider>')
def oauth_authorize(provider):
    # Flask-Login function
    if not current_user.is_anonymous():
        return redirect(url_for('index'))
    oauth = OAuthSignIn.get_provider(provider)
    return oauth.authorize()

@app.route('/callback/<provider>')
def oauth_callback(provider):
    if not current_user.is_anonymous():
        return redirect(url_for('index'))
    oauth = OAuthSignIn.get_provider(provider)
    username, email = oauth.callback()
    if email is None:
        # I need a valid email address for my user identification
        flash('Authentication failed.')
        return redirect(url_for('index'))
    # Look if the user already exists
    user=User.query.filter_by(email=email).first()
    if not user:
        # Create the user. Try and use their name returned by Google,
        # but if it is not set, split the email address at the @.
        nickname = username
        if nickname is None or nickname == "":
            nickname = email.split('@')[0]

        # We can do more work here to ensure a unique nickname, if you 
        # require that.
        user=User(nickname=nickname, email=email)
        db.session.add(user)
        db.session.commit()
    # Log in the user, by default remembering them for their next visit
    # unless they log out.
    login_user(user, remember=True)
    return redirect(url_for('index'))

最后，我的/login视图和模板可以实现这一切：

@app.route('/login', methods=['GET', 'POST'])
def login():
    if g.user is not None and g.user.is_authenticated():
        return redirect(url_for('index'))
    return render_template('login.html',
                           title='Sign In')

login.html:

{% extends "base.html" %}

{% block content %}

    <div id="sign-in">
        <h1>Sign In</h1>
        <p>
        <a href={{ url_for('oauth_authorize', provider='google') }}><img src="{{ url_for('static', filename='img/sign-in-with-google.png') }}" /></a>
    </div>
{% endblock %}

确保正确的回叫地址是注册与谷歌，用户应该只需点击“登录与谷歌”在您的登录页面上，它会注册他们，并登录他们。

我已经搜索了相当多关于使用不同的库，但他们似乎都有点矫枉过正（你可以在任何平台上使用它，但你需要吨的代码）或文档没有解释我想要什么。长话短说-我写了它从头开始，从而了解过程中的认证真正的谷歌API。它并不像它听起来那么难。基本上你需要遵循https://developers.google.com/accounts/docs/OAuth2WebServer的指导方针，就是这样。为此，你还需要在https://code.google.com/apis/console/注册以生成凭据并注册你的链接。我使用了指向我办公室IP的简单子域，因为它只允许域。
对于用户登录/管理和会话，我已经使用了这个插件的 flask http://packages.python.org/Flask-Login/-将有一些代码的基础上。
因此，首先要做的是索引视图：

from flask import render_template
from flask.ext.login import current_user
from flask.views import MethodView

from myapp import app

class Index(MethodView):
    def get(self):
        # check if user is logged in
        if not current_user.is_authenticated():
            return app.login_manager.unauthorized()

        return render_template('index.html')

所以这个视图只有在用户通过身份验证后才会打开。2谈论用户-用户模型：

from sqlalchemy.orm.exc import NoResultFound
from sqlalchemy import Column, Integer, DateTime, Boolean, String

from flask.ext.login import UserMixin
from myapp.metadata import Session, Base

class User(Base):
    __tablename__ = 'myapp_users'

    id = Column(Integer, primary_key=True)
    email = Column(String(80), unique=True, nullable=False)
    username = Column(String(80), unique=True, nullable=False)

    def __init__(self, email, username):
        self.email = email
        self.username = username

    def __repr__(self):
        return "<User('%d', '%s', '%s')>" \
                % (self.id, self.username, self.email)

    @classmethod
    def get_or_create(cls, data):
        """
        data contains:
            {u'family_name': u'Surname',
            u'name': u'Name Surname',
            u'picture': u'https://link.to.photo',
            u'locale': u'en',
            u'gender': u'male',
            u'email': u'propper@email.com',
            u'birthday': u'0000-08-17',
            u'link': u'https://plus.google.com/id',
            u'given_name': u'Name',
            u'id': u'Google ID',
            u'verified_email': True}
        """
        try:
            #.one() ensures that there would be just one user with that email.
            # Although database should prevent that from happening -
            # lets make it buletproof
            user = Session.query(cls).filter_by(email=data['email']).one()
        except NoResultFound:
            user = cls(
                    email=data['email'],
                    username=data['given_name'],
                )
            Session.add(user)
            Session.commit()
        return user

    def is_active(self):
        return True

    def is_authenticated(self):
        """
        Returns `True`. User is always authenticated. Herp Derp.
        """
        return True

    def is_anonymous(self):
        """
        Returns `False`. There are no Anonymous here.
        """
        return False

    def get_id(self):
        """
        Assuming that the user object has an `id` attribute, this will take
        that and convert it to `unicode`.
        """
        try:
            return unicode(self.id)
        except AttributeError:
            raise NotImplementedError("No `id` attribute - override get_id")

    def __eq__(self, other):
        """
        Checks the equality of two `UserMixin` objects using `get_id`.
        """
        if isinstance(other, UserMixin):
            return self.get_id() == other.get_id()
        return NotImplemented

    def __ne__(self, other):
        """
        Checks the inequality of two `UserMixin` objects using `get_id`.
        """
        equal = self.__eq__(other)
        if equal is NotImplemented:
            return NotImplemented
        return not equal

UserMixin可能有问题，但我会处理后者。您的用户模型看起来会有所不同，只要使其与flak-login兼容即可。
那么剩下的就是自我认证了。我为flask-login设置了登录视图为'login'。Login视图呈现了带有指向google的登录按钮的html- google重定向到Auth视图。它应该可以将用户重定向到google，以防它的网站只供登录用户使用。

import logging
import urllib
import urllib2
import json

from flask import render_template, url_for, request, redirect
from flask.views import MethodView
from flask.ext.login import login_user

from myapp import settings
from myapp.models import User

logger = logging.getLogger(__name__)

class Login(BaseViewMixin):
    def get(self):
        logger.debug('GET: %s' % request.args)
        params = {
            'response_type': 'code',
            'client_id': settings.GOOGLE_API_CLIENT_ID,
            'redirect_uri': url_for('auth', _external=True),
            'scope': settings.GOOGLE_API_SCOPE,
            'state': request.args.get('next'),
        }
        logger.debug('Login Params: %s' % params)
        url = settings.GOOGLE_OAUTH2_URL + 'auth?' + urllib.urlencode(params)

        context = {'login_url': url}
        return render_template('login.html',**context)

class Auth(MethodView):
    def _get_token(self):
        params = {
            'code': request.args.get('code'),
            'client_id': settings.GOOGLE_API_CLIENT_ID,
            'client_secret': settings.GOOGLE_API_CLIENT_SECRET,
            'redirect_uri': url_for('auth', _external=True),
            'grant_type': 'authorization_code',
        }
        payload = urllib.urlencode(params)
        url = settings.GOOGLE_OAUTH2_URL + 'token'

        req = urllib2.Request(url, payload)  # must be POST

        return json.loads(urllib2.urlopen(req).read())

    def _get_data(self, response):
        params = {
            'access_token': response['access_token'],
        }
        payload = urllib.urlencode(params)
        url = settings.GOOGLE_API_URL + 'userinfo?' + payload

        req = urllib2.Request(url)  # must be GET

        return json.loads(urllib2.urlopen(req).read())

    def get(self):
        logger.debug('GET: %s' % request.args)

        response = self._get_token()
        logger.debug('Google Response: %s' % response)

        data = self._get_data(response)
        logger.debug('Google Data: %s' % data)

        user = User.get_or_create(data)
        login_user(user)
        logger.debug('User Login: %s' % user)
        return redirect(request.args.get('state') or url_for('index'))

所以一切都被分成两部分--一部分用于在_get_token中获取google token，另一部分用于在_get_data中使用它和检索基本用户数据。
我的设置文件包含：

GOOGLE_API_CLIENT_ID = 'myid.apps.googleusercontent.com'
GOOGLE_API_CLIENT_SECRET = 'my secret code'
GOOGLE_API_SCOPE = 'https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/userinfo.email'
GOOGLE_OAUTH2_URL = 'https://accounts.google.com/o/oauth2/'
GOOGLE_API_URL = 'https://www.googleapis.com/oauth2/v1/'

请记住，视图必须有URL路径附加到应用程序，所以我使用这个urls.py文件，这样我就可以更容易地跟踪我的视图，并导入更少的东西到 flask 应用程序创建文件：

from myapp import app
from myapp.views.auth import Login, Auth
from myapp.views.index import Index

urls = {
    '/login/': Login.as_view('login'),
    '/auth/': Auth.as_view('auth'),
    '/': Index.as_view('index'),
}

for url, view in urls.iteritems():
    app.add_url_rule(url, view_func=view)

所有这些使得Google授权在Flask中工作。如果你复制粘贴它--它可能需要一些flask登录文档和SQLAlchemyMap的修补，但是想法是存在的。

给予Authomatic（我是这个项目的维护者）。它使用起来非常简单，可以与任何Python框架一起工作，并且支持16个OAuth 2.0、10个OAuth 1.0a提供者和OpenID。
下面是一个简单的示例，说明如何通过Google对用户进行身份验证，并获取他/她的YouTube视频列表：

# main.py

from flask import Flask, request, make_response, render_template
from authomatic.adapters import WerkzeugAdapter
from authomatic import Authomatic
from authomatic.providers import oauth2

CONFIG = {
    'google': {
        'class_': oauth2.Google,
        'consumer_key': '########################',
        'consumer_secret': '########################',
        'scope': oauth2.Google.user_info_scope + ['https://gdata.youtube.com'],
    },
}

app = Flask(__name__)
authomatic = Authomatic(CONFIG, 'random secret string for session signing')

@app.route('/login/<provider_name>/', methods=['GET', 'POST'])
def login(provider_name):
    response = make_response()

    # Authenticate the user
    result = authomatic.login(WerkzeugAdapter(request, response), provider_name)

    if result:
        videos = []
        if result.user:
            # Get user info
            result.user.update()

            # Talk to Google YouTube API
            if result.user.credentials:
                response = result.provider.access('https://gdata.youtube.com/'
                    'feeds/api/users/default/playlists?alt=json')
                if response.status == 200:
                    videos = response.data.get('feed', {}).get('entry', [])

        return render_template(user_name=result.user.name,
                               user_email=result.user.email,
                               user_id=result.user.id,
                               youtube_videos=videos)
    return response

if __name__ == '__main__':
    app.run(debug=True)

还有一个非常简单的Flask tutorial，它显示了如何通过Facebook和Twitter验证用户，并与它们的API对话以读取用户的新闻提要。

Flask-Dance是一个将Flask、Requests和OAuthlib链接在一起的新库。它有一个漂亮的API，并且内置了对Google auth的支持，along with a quickstart for how to get started。给予看吧！

我可以将接受的答案移植为使用Requests-OAuthlib而不是Rauth。截至本文撰写时，该包的最后一次提交是在2019年6月，目前有3万多个仓库使用。
要安装，请运行：

$ pip install requests_oauthlib

注意，OAUTHLIB_RELAX_TOKEN_SCOPE环境变量必须设置为True以取消Scope has changed warning。在Windows上，可以通过运行以下命令来完成此操作：
第一个
请求-OAuthlib文档可在此处找到https://requests-oauthlib.readthedocs.io/en/latest/index.html。

Flask-oauth可能是您目前最好的选择，因为flask特定的方式来完成此操作，据我所知，它不支持令牌刷新，但它可以与Facebook一起使用，我们使用它来完成此操作，它是oauth 2。如果它不需要特定于flask，您可以考虑requests-oauth

看来新模块Flask-Rauth是这个问题的答案：
Flask-Rauth是一个Flask扩展，允许您轻松地与OAuth 2.0、OAuth 1.0a和支持Ofly的应用程序进行交互。[...]这意味着Flask-Rauth将允许您的Flask网站上的用户登录到外部Web服务（即Twitter API、Facebook Graph API、GitHub等）。
请参阅：Flask-Rauth

由于oauth2 client现在已被弃用，我推荐bluemoon的建议。Flask中的OAuth2 Google身份验证的Bruno Rocha's model是使用lepture健壮的Flask-OAuthlib（pip-installable）的一个很好的起点。我建议模仿，然后扩展以满足您的需要。

并不是专门针对google的--https://github.com/lepture/flask-oauthlib，它有一个示例说明如何在https://github.com/lepture/example-oauth2-server上实现客户机和服务器。