python_web学习笔记七：flask基础篇

最新推荐文章于 2024-07-19 16:36:18 发布
最新推荐文章于 2024-07-19 16:36:18 发布
阅读量167 收藏 1
点赞数
分类专栏： python学习笔记_web篇 python笔记 文章标签： python flask1.0.2 基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42871902/article/details/102941753
版权

一、工程搭建

1.环境搭建

mkvirtualenv flask -p python3
pip install flask==1.0.2

2.第一个程序helloworld

from flask import Flask

# 创建flask对象
app = Flask(__name__)


# 使用app对象的route装饰器装饰视图函数
@app.route('/')
def index():
    return 'hello world'


# 调用app.run方法
if __name__ == '__main__':
    app.run()

  • 一些初始化的参数

import_name=__name__, # 表示导入该模块的名字, 给Flask寻找静态资源使用的。直接使用__name__。
static_folder='my_static', # 设置静态资源的存放目录，默认是 static
static_url_path='/static_tmp', # 表示访问静态资源的前缀路由，默认是 '/' + static_folder
template_folder='templates' # 存放模板的文件夹， 默认值就是 templates

3.常用的三种加载配置的方式

from flask import Flask

app = Flask(__name__)


# 加载配置
# 1.使用类加载配置(方便)
class Config(object):
    REDIS1 = "redis://127.0.0.1/1"


app.config.from_object(Config)
print(app.config.get("REDIS1"))
# 2.从配置文件加载(安全)
# app.config.from_pyfile("02_config.ini")
# print(app.config.get("REDIS2"))
# 3.从环境变量加载，本质是从配置文件中加载(灵活、安全)
# silent: False 表示不安静处理，如果找不到环境变量，会抛出异常。默认是False
# silent: True 表示安静处理，如果找不到环境变量，不会抛出异常。
# 注意：环境变量对应值为配置文件的文件名，不然读取不到
app.config.from_envvar("FLASK_CONFIG", silent=True)
print(app.config.get("REDIS2"))
if __name__ == '__main__':
    app.run()

4.实际开发中常用加载方式

from flask import Flask


def create_app(config):
    app = Flask(__name__)
    # 1.从配置类中加载配置
    app.config.from_object(config)
    # 2.从环境变量中加载配置
    app.config.from_envvar("REDIS2", silent=True)
    return app


class Config(object):
    REDIS1 = "redis://127.0.0.1/1"


app = create_app(Config)
print(app.config.get("REDIS1"))
print(app.config.get("REDIS2"))

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

5.app.run参数

from flask import Flask

app = Flask(__name__)


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


if __name__ == '__main__':
    # 1.host 绑定的ip地址
    # 2.port 监听的端口号
    # 3.debug 是否开启调试模式
    # 开始调试模式后，保存自动重启，把错误显示在页面上，方便调试
    app.run(host='0.0.0.0', port=5001, debug=True)

6.终端启动方式

# 1.设置环境变量
export FLASK_APP=app所在模块
export FLASK_ENV=development  # 表示运行在开发模式，生产模式production
# 2.运行
flask run -h 0.0.0.0 -p 5001

二、路由与蓝图

1.查询路由的三种方式

from flask import Flask, jsonify

app = Flask(__name__)


@app.route('/')
def index():
    # 3.自定义一个接口
    data = {}
    for rule in app.url_map.iter_rules():
        data[rule.endpoint] = rule.rule
    return jsonify(data)


@app.route('/index2')
def index2():
    return 'index2'


# 1.直接打印url_map
print(app.url_map)
# 2.终端运行时
# flask routes 模块名

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

2.指定请求方式

from flask import Flask

app = Flask(__name__)


@app.route('/', methods=["GET"])
def index():
    return 'index'


@app.route('/index2', methods=["POST"])
def index2():
    return 'index2'


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

3.允许跨域

  • 安装

    pip install falsk-cors

  • 使用

    from flask import Flask
# 导入
from flask_cors import CORS

app = Flask(__name__)
# 允许跨域
CORS(app)


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


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

4.蓝图基本使用

from flask import Flask, Blueprint

app = Flask(__name__)
# 1.创建蓝图对象
bp = Blueprint("user", __name__)


# 2.用蓝图对象装饰
@bp.route('/')
def index():
    return 'index'


# 3.注册
app.register_blueprint(bp)
if __name__ == '__main__':
    app.run()

5.把蓝图抽离成包

  • main.py

    from user import user_bp
from flask import Flask

app = Flask(__name__)
# 注册
app.register_blueprint(user_bp)

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

  • user/__init__.py

    from flask import Blueprint

# 创建蓝图
user_bp = Blueprint("user", __name__)
from . import views

  • user/views.py

    from user import user_bp


# 使用蓝图对象装饰
@user_bp.route("/")
def index():
    return "index"

6.蓝图的一些参数

# user/__init__.py
# name: 蓝图对象名字，在同一个app中，不能有相同名称的蓝图对象
# import_name: __name__
# static_url_path: 蓝图自己的静态资源路由
# static_folder: 蓝图自己的静态资源文件夹
# template_folder: 蓝图自己的模板文件夹

# 使用url_prefix指定蓝图对象url前缀
app.register_blueprint(user_bp, url_prefix='/user')

注意:
  如果蓝图模板文件夹中有和app模板文件夹中同名的模板文件，会优先返回app中的模板文件。

三、请求与响应

1.处理请求

a.路径传参

from flask import Flask

app = Flask(__name__)


@app.route('/<user_id>')
def index(user_id):
    return 'user_id is %s' % user_id


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

b.常用的转换器

from flask import Flask

app = Flask(__name__)


@app.route('/str/<string:param>')
def string_view(param):
    return 'param is %s' % param


@app.route('/int/<int:param>')
def int_view(param):
    return 'param is %s' % param


@app.route('/float/<float:param>')
def float_view(param):
    return 'param is %s' % param


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

c.自定义转换器

from flask import Flask
from werkzeug.routing import BaseConverter

app = Flask(__name__)


# 1.自定义自己的转换器类
class Mobile(BaseConverter):
    # 匹配手机号
    regex = r"1[3-9]\d{9}"


# 2.添加
app.url_map.converters["mobile"] = Mobile

# 3.使用
@app.route('/<mobile:param>')
def index(param):
    return 'param is %s' % param


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

d.request对象获取参数

from flask import Flask, request, jsonify

app = Flask(__name__)


@app.route('/')
def index():
    # 查询字符串
    # data = request.args.get("name")
    # 表单
    # data = request.form.get("name")
    # 原始数据
    # data = request.data
    # json数据
    # data = jsonify(request.json)
    # files数据
    # data = request.files.get("a")
    # headers头
    # data = request.headers.get("name")
    # url路由
    # data = request.url
    # method请求方法
    data = request.method
    return data


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

2.处理响应

a.返回响应

from flask import Flask, make_response

app = Flask(__name__)


@app.route('/')
def index():
    # 1.直接返回
    return 'index'


@app.route('/index2')
def index2():
    # 2.构建响应对象
    response = make_response("index2")
    return response


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

b.返回自定义状态码和头部

from flask import Flask, make_response

app = Flask(__name__)


@app.route('/')
def index():
    # 1.以元组的方式返回
    return 'index', 201, {"name": "lw"}


@app.route('/index2')
def index2():
    # 使用响应对象设置
    response = make_response("index2")
    response.status_code = 404
    response.headers["age"] = 18
    return response


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

c.返回json数据

import json

from flask import Flask, jsonify

app = Flask(__name__)


@app.route('/')
def index():
    data = {
        "name": "lw",
        "age": 18
    }
    # 1.使用json模块
    return json.dumps(data), 200, {"Content-Type": "application/json"}


@app.route("/2")
def index2():
    data = {
        "qq": '123'
    }
    # 2.字典参数
    return jsonify(data)


@app.route("/3")
def index3():
    # 3.关键字参数
    return jsonify(tel="13245")


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

d.返回jinja2模板

from flask import Flask, render_template

app = Flask(__name__)


@app.route('/')
def index():
    response = render_template("user/render.html", name="laowang", age=18)
    return response


if __name__ == '__main__':
    app.run()
  • render.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>{{ name }}</h1>
    <h1>{{ age }}</h1>
</body>
</html>

e.重定向

from flask import Flask, redirect

app = Flask(__name__)


@app.route('/')
def index():
    return redirect("/index2")


@app.route('/index2')
def index2():
    return redirect("https://www.baidu.com")


if __name__ == '__main__':
    app.run(e)

3.cookie与session

a.cookie

from flask import Flask, make_response, request

app = Flask(__name__)

# 设置cookie
@app.route('/set_cookie/<name>')
def set_cookie(name):
    # 构造响应对象
    response = make_response("set_cookie")
    # max_age用户设置cookie有效期，单位秒
    response.set_cookie("name", name)
    return response


# 获取cookie
@app.route('/get_cookie')
def get_cookie():
    name = request.cookies.get("name")
    return "cookie is %s" % name

# 删除cookie
@app.route('/delete_cookie')
def delete_cookie():
    # 相当于把max_age设置为0
    response = make_response("delete_cookie")
    response.delete_cookie("name")
    return response


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

b.session

from flask import Flask, session

app = Flask(__name__)
# 设置secret_key
app.secret_key = "asdgdg"
# 设置session
@app.route('/set_session/<name>')
def set_session(name):
    session['name'] = name
    return 'index'

# 获取session
@app.route('/get_session')
def get_session():
    name = session.get("name")
    return str(name)


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

四、请求钩子与上下文

1.异常处理

a.abort的使用

from flask import Flask, abort

app = Flask(__name__)


@app.route('/')
def index():
    # 抛出异常
    abort(404)
    return 'index'


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

b.异常捕获处理

from flask import Flask, abort

app = Flask(__name__)


@app.errorhandler(404)
def func_404(e):
    return "这是一个漂亮的404页面", 404


@app.errorhandler(ZeroDivisionError)
def func_0(e):
    return "0除异常", 502


@app.route('/')
def index():
    # 1/0
    abort(404)
    return 'index'


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

2.请求钩子

a.基本使用

from flask import Flask

app = Flask(__name__)

# 在所有请求开始前执行一次
@app.before_first_request
def before_first_request():
    print("before_first_request")

# 在所有请求开始前执行
@app.before_request
def before_request():
    print("before_request")

# 在所有请求，视图函数执行完后执行
@app.after_request
def after_request(response):
    print("after_request")
    return response

# 在钩子后执行
@app.teardown_request
def teardown_request(e):
    print("teardown_request")


@app.route('/')
def index():
    print("index")
    return 'index'


@app.route('/index2')
def index2():
    print("index2")
    return 'index2'


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

b.认证示例

from flask import Flask, request, session, jsonify, g

app = Flask(__name__)
# 两种设置方式
app.secret_key = "fdasdgf"
# app.config["SECRET_KEY"] = "QERWEFD"

# 准备用户
users = [
    {"user_id": 1, "username": "laowang", "password": "123456"}
]


# 登录接口
@app.route('/login')
def login():
    username = request.args.get("username")
    password = request.args.get("password")
    for user in users:
        if username == user["username"] and password == user["password"]:
            # 登录成功
            session["user_id"] = user["user_id"]
            return "登录成功"
    return '登录失败'


@app.before_request
def before_request():
    user_id = session.get("user_id")
    if user_id is None:
        g.user = None
    else:
        for user in users:
            if int(user_id) == user["user_id"]:
                # 如果找到用户
                g.user = user


# 使用装饰器继续优化视图函数代码
# 强制登录装饰器
def login_required(func):
    def wrapper(*args, **kwargs):
        # 检测
        if g.user is None:
            return "请先登录"
        else:
            return func(*args, **kwargs)
    return wrapper


@app.route("/user_info")
@login_required
def user_info():
    return jsonify(g.user)


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

3.上下文

a.current_app:指向处理当前请求的app对象

from flask import Flask, current_app

app = Flask(__name__)


class Config(object):
    REDIS = "redis://192.168.230.128:6379/1"


app.config.from_object(Config)
print(app.config.get("REDIS"))


@app.route('/')
def index():
    # current_app指向处理当前请求的app，它是一个代理
    return current_app.config.get("REDIS")

# 蓝图
from user import user_bp

app.register_blueprint(user_bp, url_prefix="/user")

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

b. g:临时的全局变量，用于参数传递

from flask import Flask, g

app = Flask(__name__)


@app.before_request
def before_request():
    g.user_id = 123


def func1():
    print(g.user_id)


@app.route('/')
def index():
    func1()
    return str(g.user_id)


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

c.测试

from flask import Flask, current_app, g, request, session

app = Flask(__name__)


def test_request_context():
    print(request)
    print(session)
    print(g)
    print(current_app)


@app.route('/')
def index():
    # 1.正常请求可以使用
    test_request_context()
    return 'index'


if __name__ == '__main__':
    # 在上下文外面，不能使用，会直接抛出异常
    # test_request_context()
    # app.run(host='192.168.230.128', debug=True)
    # 2.构建测试请求上细纹对象
    # environ = {'wsgi.version': (1, 0), 'wsgi.input': '', 'REQUEST_METHOD': 'GET', 'PATH_INFO': '/',
    #            'SERVER_NAME': 'baidu server', 'wsgi.url_scheme': 'http', 'SERVER_PORT': '80'}  # 模拟解析客户端请求之后的wsgi字典数据
    # with app.request_context(environ):
    #     # 构建了一个请求上下文环境，4个对象都可用
    #     test_request_context()

    # 3.构建应用上下文对象
    with app.app_context():
        print(current_app)
        print(g)
        # 请求上下文对象不可用
        # print(request)

五、Flask-RESTful

1.起步

pip install flask-restful

from flask import Flask
from flask_restful import Resource, Api

app = Flask(__name__)

# 1.创建API对象
api = Api(app)


# 2.定义视图类
class HelloWorldResource(Resource):
    def get(self):
        return {"msg": "hello world"}

    def post(self):
        return {"msg": "hello world"}


# 3.使用api对象绑定视图类和路由
api.add_resource(HelloWorldResource, "/")

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

2.蓝图中使用flask-restful

from flask import Flask, Blueprint
from flask_restful import Resource, Api

app = Flask(__name__)
# 1.创建蓝图对象
user_bp = Blueprint("user", __name__)

# 2.创建api对象
api = Api(user_bp)


# 3.定义视图类
class UerInfoResource(Resource):
    def get(self):
        return {"msg": "user_info"}


# 4.使用api对象绑定视图类和路由的关系
api.add_resource(UerInfoResource, "/", endpoint='userinfo')
# 5.把蓝图对象注册到app中
app.register_blueprint(user_bp)

if __name__ == '__main__':
    print(app.url_map)
    app.run()

3.类视图使用装饰器的方式

from flask import Flask
from flask_restful import Resource, Api

app = Flask(__name__)


def decorator1(func):
    def wrapper(*args, **kwargs):
        print("decorator1")
        return func(*args, **kwargs)

    return wrapper


def decorator2(func):
    def wrapper(*args, **kwargs):
        print("decorator2")
        return func(*args, **kwargs)

    return wrapper


api = Api(app)


class Index(Resource):
    # 1.列表的方式,所有的请求方式都会受到影响
    # method_decorators = [decorator1, decorator2]
    # 2.字典的方式
    method_decorators = {
        "get": [decorator1, decorator2],
        "post": [decorator1],
    }

    def get(self):
        return {"msg": "get"}

    def post(self):
        return {"msg": "post"}


api.add_resource(Index, '/')

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

4.使用RequestParser获取参数

from flask import Flask, request
from flask_restful import Resource, Api
from flask_restful.reqparse import RequestParser
from flask_restful.inputs import int_range
import re

app = Flask(__name__)
api = Api(app)


def mobile(mobile_str):
    if re.match(r"^1[3-9]\d{9}$", mobile_str):
        return mobile_str
    else:
        raise ValueError("%s is not a mobile" % mobile_str)


class Index(Resource):
    def get(self):
        # 1.创建RequestParser对象
        parser = RequestParser()
        # 2.添加需要解析的参数
        parser.add_argument("a")
        # 3.调用parse_args解析参数
        req = parser.parse_args()
        # 4.直接使用
        return {"a": req.get("a")}

        # # 也可以用原来的request对象获取参数
        # a = request.args.get("a")
        # return {"a": a}

    def post(self):
        parser = RequestParser()
        parser.add_argument(
            "a",  # 参数的名称
            location=["args", "form"],  # 描述该参数出现的位置
            required=True,  # 请求是否一定要携带对应参数。True必须，False不必
            # help="missing a param",  # 自定义提示
            action="append",  # 同名参数处理方式,默认store,保留第一个。append则添加
            # type=int,  # 匹配参数类型
            # type=int_range(1, 10)
            type=mobile
        )
        req = parser.parse_args()
        return {"a": req.get("a")}


api.add_resource(Index, "/")

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

5.marshal工具

from flask import Flask
from flask_restful import Resource, Api, fields, marshal_with, marshal

app = Flask(__name__)
api = Api(app)


# 模拟模型类
class User(object):
    def __init__(self, user_id, name, age):
        self.user_id = user_id
        self.name = name
        self.age = age


# 定义需要返回的数据格式
my_fields = {
    "user_id": fields.Integer,
    "name": fields.String,
    "age": fields.Integer
}


class UserInfo(Resource):
    # 1.使用装饰器的方式
    @marshal_with(my_fields, envelope="data")
    def get(self):
        user = User(1, "laowang", 18)
        # data = {
        #     "user_id": user.user_id,
        #     "name": user.name,
        #     "age": user.age,
        # }
        return user
    # def get(self):
    #     # 2.以函数的方式
    #     user = User(1, "laowang", 20)
    #     return marshal(user, my_fields, envelope="data")


api.add_resource(UserInfo, "/user_info")
if __name__ == '__main__':
    app.run()

6.修改最终返回的JSON数据格式

  • 原生的做法
import json

from flask import Flask, jsonify

app = Flask(__name__)


@app.after_request
def after_request(response):
    data = json.loads(response.data.decode())
    if "message" not in data:
        data = {
            "message": "ok",
            "data": data
        }
    response.data = json.dumps(data)
    return response


@app.route('/user_name')
def user_name():
    data = {
        "name": "laowang"
    }
    return jsonify(data)


@app.route('/user_age')
def user_age():
    data = {
        "message": "ok",
        "data": {
            "age": 18
        }
    }
    return jsonify(data)


if __name__ == '__main__':
    app.run()
  • Flask-RESTful的做法
import json

from flask import Flask, make_response, current_app
from flask_restful import Resource, Api
from flask_restful.utils import PY3

app = Flask(__name__)
api = Api(app)


# 普通的做法
# @api.representation("application/json")
# def representation(data, code, headers):
#     if "message" not in data:
#         data = {
#             "message": "ok",
#             "data": data
#         }
#     response = make_response(json.dumps(data))
#     response.status_code = code
#     response.headers.extend(headers)
#     return response

# 建议做法
@api.representation("application/json")
def output_json(data, code, headers=None):
    if "message" not in data:
        data = {
            "message": "ok",
            "data": data
        }
    settings = current_app.config.get('RESTFUL_JSON', {})

    if current_app.debug:
        settings.setdefault('indent', 4)
        settings.setdefault('sort_keys', not PY3)
    dumped = json.dumps(data, **settings) + "\n"
    resp = make_response(dumped, code)
    resp.headers.extend(headers or {})
    return resp


class UserInfo(Resource):
    def get(self):
        return {"age": 18}


api.add_resource(UserInfo, "/")

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

六、curl命令

curl -X http请求方式 请求的路径url -H 请求头字段 -d 请求体数据
唯羽
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Flask 入门教程
qq_36309304的博客
06-23 4071
百度百科：Flask是一个使用 Python 编写的轻量级 Web 应用框架1，也被称为 “微服务框架” ，因为使用简单的核心（ Werkzeug WSGI工具包2、 Jinja2 模板引擎3）且支持插件扩展。werkzeug是Flask使用的底层WSGI库， 实现路由、调试和Web服务器网关接口。（WSGI，全称 Web Server Gateway interface，是为 Python 语言定义的Web服务器和Web应用程序之间的一种简单而通用的接口）。
http请求样式
cncjh的收集
06-23 406
Content-Type: application/x-www-form-urlencoded请求样式 POST /app/a/update HTTP/1.1 Host: XXX.XXX.XXX.XXX:9999 Content-Type: application/x-www-form-urlencoded bili=11&id1=e0e19646b23d11e799d10016...
【学习笔记】PythonWeb（Ⅰ）—— Flask
Eddie_hyh的博客
04-08 1180
PythonWeb第一部分：Flask
Python-web开发学习笔记（3）：Flask Demo，一个网站开发小案例
尚拙的博客
05-24 3817
介绍完HTML标签，我们来搞一个简单的网站小案例，带大家更进一步理解HTML网页和web框架之间是怎么运作的，本篇以做一个简单的注册页面为例。本文为了方便，使用轻量级的flask框架进行案例的设计，快速制作一个简单的实现注册账户的web服务。浏览器通过我们用户进行的一些操作，向后台发起请求，后台接收到请求后，会解析请求字段，根据字段对应的要求，执行对应的功能模块（例如执行def xxx方法），并将执行结果返回到某个HTML文件中，后台接收到返回后，会作为请求的响应返回给浏览器，响应中包含了一堆HTML标签，
Flask框架学习笔记之表单基础介绍与表单提交方式
09-18
本篇文章将深入探讨Flask中的表单基础和两种主要的提交方式——GET和POST。 首先，让我们了解表单的基本概念。在HTML中，表单是由`<form>`标签定义的，它包含了各种表单元素，如文本框、密码框、文本区域、单选按钮...
Flask框架学习笔记之使用Flask实现表单开发详解
09-18
本篇文章将深入探讨如何使用Flask实现表单的定义、数据提交以及验证。首先，我们将关注HTML中的基本表单元素，然后讨论如何使用Flask的内建功能与第三方库WTForms协同工作以实现更复杂的表单处理。 一、HTML基础...
Flask学习笔记(9）源码
11-11
在本篇Flask学习笔记(9)中，我们将深入探讨Flask框架的源码，重点关注其核心概念和组件，特别是与Python蓝图（Blueprint）相关的部分。Flask是Python中的一个轻量级Web服务程序，它以其简洁、灵活的特性深受开发者...
Flask学习笔记8源码
11-07
**Flask学习笔记8源码解析** 在Python的Web开发领域，Flask是一个轻量级且灵活的框架，因其简洁的API和强大的扩展性而受到开发者喜爱。本篇笔记将深入探讨Flask的核心概念和常见用法，通过分析"demo8"这个压缩包中...
Flask学习笔记（6）源码
11-06
在本篇Flask学习笔记（6）中，我们将深入探讨Flask这个轻量级的Python Web框架。Flask以其简洁的API和高度可扩展性深受开发者喜爱，它允许开发者用少量代码实现功能丰富的Web应用。以下是对源码的详细解析。 首先，...
华为od机试真题 — 代表团坐车(Python)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
07-17 575
【华为od机试真题 】代表团坐车(Python) 某组织举行会议，来了多个代表团同时到达，接待处只有一辆汽车可以同时接待多个代表团，为了提高车辆利用率，请帮接待员计算可以坐满车的接待方案输出方案数量。
【Python如何将字符串连接在一起并使用`join()`方法】
最新发布
qq_36253366的博客
07-19 177
方法是字符串对象的方法，而不是列表或元组等序列类型的方法。因此，你需要先指定一个用作分隔符的字符串，然后调用这个字符串的。方法将字符串连接在一起，你需要首先确保这些字符串被存储在一个序列类型中（如列表或元组），然后调用这个序列的。方法是一个字符串方法，它用于将序列（如列表、元组等）中的元素以指定的字符连接生成一个新的字符串。列表中的所有字符串元素使用空格作为分隔符连接成一个新的字符串。方法，并将你想要作为分隔符的字符串作为参数传递给。方法，并将包含要连接字符串的序列作为参数传递。
Python每日一题：回文数
xiongxiaoxuan的博客
07-16 274
回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。给你一个整数 x ，如果 x 是一个回文整数，返回 true；否则，返回 false。解释：从左向右读, 为 -121。从右向左读, 为 121-。因此它不是一个回文数。先将整数x转化为字符串形式，判断x和它的反转形态是否完全相等。解释：从右向左读, 为 01。需注意：True和False首字母大写！提示：-231
IPython 日志秘籍：%logstate 命令全解析
2401_85812026的博客
07-17 564
logstate命令是 IPython 日志系统的重要组成部分，它帮助我们掌控日志记录的状态。通过本文的介绍，你应该对如何在 IPython 中使用%logstate查看日志状态有了更深入的理解。记住，合理利用日志系统，可以让你的数据探索过程更加透明和可追溯。本文详细介绍了 IPython 的%logstate命令，包括其基本概念、基本用法、输出解析以及实战示例。希望本文能够帮助读者更好地利用 IPython 的日志系统，优化数据探索和科学计算的工作流。记住，掌握%logstate。
【Python 中的内存管理有哪些优缺点】
qq_36253366的博客
07-19 200
Python中的内存管理是一个复杂而高效的系统，它通过自动化和抽象化的方式极大地简化了程序员的内存管理负担，但同时也存在一些潜在的缺点。
N7翻译实战
tjl521314_21的博客
07-17 302
本周完成项目实战用于训练一个简单的序列到序列（seq2seq）模型以实现英语到法语的翻译。数据预处理、模型构建、训练以及可视化损失的过程。本周学习了构建和训练一个简单的seq2seq模型用于英语到法语的翻译，对前面的知识做了一个综合的运用。
Python中使用三方库SpeechLib实现文本转换语音文件的示例(Win10)
m0_64880493的博客
07-16 181
开始用创建对象的方法CreateObject 分别创建了语音引擎对象与语音文件流对象。调用流对象的Open()方法实现语音流数据写入音频输出文件。
python训练模型报错：BrokenPipeError: [Errno 32] Broken pipe
Dxy1239310216的博客
07-18 279
如果问题持续存在，并且你的项目不是必须在 Windows 上运行，考虑在 Unix/Linux 系统上运行你的代码。确保在数据加载器中使用的任何自定义函数或类都是可序列化的，因为多进程需要能够在不同进程间传递它们。进行多进程数据加载时尤其常见，尤其是在 Windows 系统上，因为 Windows 对多进程的支持与 Unix/Linux 系统有所不同。有时候，错误可能是由其他部分的代码引起的，而不是直接由数据加载器引起。如果问题依然存在，你可能需要更详细地检查你的代码或寻求更专业的帮助。
httpx 的使用
qq_39217312的博客
07-15 810
httpx 是一个可以支持 HTTP/2.0 的库还有一个是： hyper 库这里有一个由HTTP/2.0的网站： https://spa16.scrape.center/使用 requests 库 进行爬取 报错：安装： httpx pip3 install httpx 这样安装并不能支持 HTTP/2.0如果想要支持，需要这样安装：pip3 install httpx[http2]输出：这里访问的HTTP/1.0的网站，并且依次打印除了 ， 响应状态码(status_code),响应头信息(header

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值