from flask import Flask, render_template


app = Flask(__name__)

@app.route('/welcome')
def welcome():
    return render_template('welcome.html', name='小明')


app.run(port=5500)

from flask import Flask, jsonify, render_template, Response


app = Flask(__name__)

@app.route('/text')
def get_text():
    return '返回文本'

@app.route('/dict')
def get_dict():
    return {'state': 0}


@app.route('/json')
def get_json():
    return jsonify({'state': 0})


@app.route('/html')
def get_html():
    return render_template('index.html')

@app.route('/response')
def get_resonponse():
    return Response('Not Found', status=404)

if __name__ == '__main__':
    app.run(port=5566)

def make_response(self, rv):
    status = headers = None

    # unpack tuple returns
    if isinstance(rv, tuple):
        len_rv = len(rv)

        # a 3-tuple is unpacked directly
        if len_rv == 3:
            rv, status, headers = rv
        # decide if a 2-tuple has status or headers
        elif len_rv == 2:
            if isinstance(rv[1], (Headers, dict, tuple, list)):
                rv, headers = rv
            else:
                rv, status = rv
        # other sized tuples are not allowed
        else:
            raise TypeError(
                "The view function did not return a valid response tuple."
                " The tuple must have the form (body, status, headers),"
                " (body, status), or (body, headers)."
            )

    # the body must not be None
    if rv is None:
        raise TypeError(
            "The view function did not return a valid response. The"
            " function either returned None or ended without a return"
            " statement."
        )

    # make sure the body is an instance of the response class
    if not isinstance(rv, self.response_class):
        if isinstance(rv, (text_type, bytes, bytearray)):
            # let the response class set the status and headers instead of
            # waiting to do it manually, so that the class can handle any
            # special logic
            rv = self.response_class(rv, status=status, headers=headers)
            status = headers = None
        elif isinstance(rv, dict):
            rv = jsonify(rv)
        elif isinstance(rv, BaseResponse) or callable(rv):
            # evaluate a WSGI callable, or coerce a different response
            # class to the correct type
            try:
                rv = self.response_class.force_type(rv, request.environ)
            except TypeError as e:
                new_error = TypeError(
                    "{e}\nThe view function did not return a valid"
                    " response. The return type must be a string, dict, tuple,"
                    " Response instance, or WSGI callable, but it was a"
                    " {rv.__class__.__name__}.".format(e=e, rv=rv)
                )
                reraise(TypeError, new_error, sys.exc_info()[2])
        else:
            raise TypeError(
                "The view function did not return a valid"
                " response. The return type must be a string, dict, tuple,"
                " Response instance, or WSGI callable, but it was a"
                " {rv.__class__.__name__}.".format(rv=rv)
            )

    # prefer the status if it was provided
    if status is not None:
        if isinstance(status, (text_type, bytes, bytearray)):
            rv.status = status
        else:
            rv.status_code = status

    # extend existing headers with provided headers
    if headers:
        rv.headers.extend(headers)

    return rv

@app.route("/image")
def image():
    f = open("static/public/pic/coolpython.png", 'rb')
    resp = Response(f.read(), mimetype="image/jpeg")
    return resp

class ImageResponse(Response):
    default_mimetype = 'image/jpeg'

@app.route("/image")
def image():
    f = open("static/public/pic/coolpython.png", 'rb')
    resp = ImageResponse(f.read())
    return resp

class ImageResponse(Response):
    default_mimetype = 'image/jpeg'

app = Flask(__name__)
app.response_class = ImageResponse

@app.route("/image")
def image():
    f = open("static/public/pic/coolpython.png", 'rb')
    return f.read()