day052 Flask基础，模板

最新推荐文章于 2024-08-04 21:17:31 发布
最新推荐文章于 2024-08-04 21:17:31 发布
阅读量276 收藏
点赞数 1
分类专栏： 学习日志
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Michael_Cool/article/details/79662196
版权

今天了解Flask框架的： 获取的请求数据，异常捕获，请求钩子，状态保持，上下文，Flast-script,以及模板的使用

获取请求数据

  • 通过使用request.<属性>的方式，获取request对象传过来的数据

  • 常用的属性如下：

    • method ,记录请求使用的HTTP方法，类型为：GET/POST
    • heafers,记录请求中的报文头，类型为：EnvironHeaders
    • url,记录请求的URL地址，类型为：string
    • cookies,记录请求中的cookies信息，类型为：Dict
    • args,记录请求中的查询参数，类型为：MultiDict
    • form,记录请求中的表单数据，类型为：MultiDict
    • data,记录请求的数据，并且转换为字符串
    • files,记录请求上传的文件
    • 调用方法：直接使用request.<属性>即可
    print 'method: %s' % request.method
print 'headers: %s' % request.headers
print 'url: %s' % request.url
print 'cookies: %s' % request.cookies


# args: name=XXX  form:name=XXX data=XXX file=图片


print 'args: %s' % request.args.get('name')
print 'form: %s' % request.form.get('name')
print 'data: %s' % request.data
print 'files: %s' % request.files


# 保存图片到当前目录


# 需要设置当前项目的工作目录, 这样传入文件路径时, '.'就可以表示当前项目根目录

image_file = request.files.get('image')
image_file.save('./image.jpg')

异常获取（理解）

  • 使用 errorhandler装饰器捕获希望捕获的异常信息。
  • 捕获到异常时，可对异常进行进一步的处理，自定义渲染过的404异常或者500异常页面并且返还给浏览器

abort方法

  • 可以抛出一个给定状态代码的异常
  • 如：
    abort(404) # 抛出一个404异常

errorhandler装饰器

  • 注册一个指定异常，当该异常发生时，执行errorhandler装饰器装饰的函数
  • 如：
# 如果有404异常抛出，捕获到，并且执行关联的函数
@app.errorhandler(404)
def internal_server_error(error) # 参数是捕获到的异常
    return '网页找不到了'， 404

请求钩子（理解）

  • 类似django中的中间键，在请求的前后执行额外的任务
  • Flask支持如下4种请求钩子
    1. befor_first_request:在处理第一个请求之前运行，再次发起相同的的请求就不在执行
    2. before_request：在每次请求之前运行
    3. after_request：在每次请求后运行，前提是没有未处理的异常就抛出
    4. teardown_request：在每次请求后运行
@app.route('/')
def hello_world():
    print '这里是视图主逻辑代码'
    return 'hello world'


# before_first_request:在处理第一个请求之前运行，如：连接数据库操作
@app.before_first_request
def before_first_request():
    print 'before_first_request'


# before_request:在每次请求前运行，如：对数据进行校验的操作，如果有问题，直接返回，不用再执行匹配的视图函数
@app.before_request
def before_request():
    print 'before_request'


# after_request:在每次请求结束后执行（没有抛出异常），如：去拼接响应头信息，让所有的json数据，统一增加Content-Type:application/json属性
@app.after_request
def after_request(response):
    print 'after_request'
    response.headers['Content-Type'] = 'application/json'
    return response


# 　teardown_request:在每次请求结束后执行（即使抛出异常），可以捕获到相应的异常
@app.teardown_request
def teardown_request(error):  # 参数为捕获到的异常信息
    print 'tearddown_request %s'% error

执行结果：

这里写图片描述

状态保持

  • 让浏览器的请求状态可以保持，不用每次都重新输入数据
  • 为什么需要状态保持，因为http是一种无状态协议，不会保持某一次请求所产生的信息，即没有记忆能力，每一次请求都是独立的。但是需要保持请求的状态信息。
  • 状态保持的方式：
    1. cookie:数据存储在客户端，节省服务器空间，缺点是不安全
    2. session：会话，数据存储在服务器上

设置cookie

  • 需要导入make_response方法，将return返回的数据当做参数传给这个方法并且使用set_cookie方法进行cookie的设置
from flask imoprt Flask,make_response
@app.route('/cookie')
def set_cookie():
    resp = make_response('this is to set cookie')
    resp.set_cookie('username', 'itcast')
    return resp

这里写图片描述

获取cookie

  • 导入request对象，使用request.cookies.get()方法进行获取
from flask import Flask,request
#获取cookie
@app.route('/request')
def resp_cookie():
    resp = request.cookies.get('username')
    return resp

这里写图片描述

设置session

  • flask的session与其他框架不同的的一点是，它的session是完全保留在客户端浏览器的
  • 往flask的session中写入数据，最终会以json字符串的形式，经过base64编码写入到用户浏览器的cookieli里

  • 为什么要这样做？这样不是不安全吗？

    1. flask的最大特点就是轻巧灵活，这样做更符合作者和flask的气质
    2. session存储前是需要加盐混淆代码，并且进行加密处理的，保证了session在客户端的安全
    3. 考虑到负载均衡的问题，如使用Nginx进行负载均衡，将session存储在服务器端的架构，每次请求，nginx路由的服务器会不同，每次当需要使用session信息时，服务器还需要从统一的redis等数据库获取session信息。而flask处理的方式是直接将整个session的完整信息直接和cookies一起传送过来，不论路由到那一台服务器，都可以直接调用session数据，更为方便
    4. 其实，实际项目中，还是需要将session数据转移到redis中的，Flask-sesssion拓展中可以实现

  • 设置步骤

    1. 设置secret-key
    2. 导入session对象
    3. 使用 session[‘key’] = ‘value’的形式进行设置

  • 读取

    • 使用 session[‘key’]进行读取操作
 # 设置session前需要设置secret_key，session数据会加密保存在浏览器cookie中
app.secret_key = 'michael'# "michael"为加的盐值，是做内容混淆用的，不能告诉别人

# 设置session
@app.route('/set_session')
def set_session():
    session['user_name']= "michael"
    return redirect(url_for("read_session"))

# 读取session
@app.route('/read_session')
def read_session():
    user_name = session['user_name']
    return "user_name:%s"%user_name

上下文（理解）

  • 上下文相当于一个容器，保存了Flask程序运行过程中的一些信息
  • 有两种上下文：请求上下文和应用上下文

请求上下文

  • 能满足请求过程中的信息调用和设置的对象
  • 有request对象和session对象

request对象

  • 封装了Http请求的内容，针对的时http请求，如，user = request.args.get(‘user’),获取的是get请求时的参数
  • 当 app = Flask(name)之后，创建了应用对象app，在每次http请求发生时，WSGI-server调用Flask.call(),在Flask的内部创建了request对象
  • app对象的生命周期大于request对象，一个app存活期间，可能发生多次request请求
  • 最终通过return，redirect,或者render_template生成response对象。返回给客户端

session对象

  • 记录了请求会话中的信息，针对的时用户信息。如，session[‘name’]=user.id,可以记录用户信息。还可以通过session.get(‘name’)来获取用户信息

应用上下文

  • 是请求上下文中的一个对app的代理（local proxy）
  • 主要作用是帮助request获取当前的应用
  • 它是与request同生共灭的
  • 包括 current_app 和 g 变量

current_app

  • 一种应用程序上下文，用来存储应用程序中的变量
  • 如current_app.name可以当存储在current_app中的name值
  • 可以存储的信息有：
    1. 应用的启动脚本是哪个文件，启动时指定了那些参数
    2. 加载了哪些配置信息，导入了哪些配置
    3. 连接了哪个数据库
    4. 有哪些public的工具类，常量
    5. 应用跑在哪个机器上，IP多少，内存大

g变量

  • 是应用上下文中一个临时的全局变量
  • 可以在一下请求中，在不同的函数（如钩子函数和url匹配的视图函数）之间传递值

@app.route('/')
def hello_world():
    print "这是主逻辑代码 %s"%g
    return '{"code":0,"msg":"执行ok"}'

@app.before_first_request
def before_first_request():
    # g变量可以在一次请求里的多个函数之间传递值
    g.name = "xiaoming"
    print "before_first_request"

@app.before_request
def before_request():
    # request.args.get('xxx'),可以获取request里的数据
    print "before_request %s" %g.name

执行结果

这里写图片描述

请求上下文和应用上下文的区别

  • 请求上下文：保存了客户端和服务器交互的数据
  • 应用上下文：在应用程序运行的过程中，保存的一些配置信息

Flask-script

  • 能够让Flask服务器通过命令行的方式启动的拓展模块
  • 实现步骤
    1. 从flask_script中导入Manager类
    2. 将app作为参数传给Manage方法，完成Manager类与app的关联
    3. 运行的时候使用：manager.run()命令
from flask import Flask
from flask_script import Manager

app = Flask(__name__)
# 把 Manager 类和应用程序实例进行关联
manager = Manager(app)

@app.route('/')
def index():
return '床前明月光'

if __name__ == "__main__":
manager.run()

命令行传参

  • 可以在命令行中给Flask应用传参，通过python hello.py runserver --help来查看可供设置的参数

这里写图片描述

模板使用

  • 模板是一个包含响应文本的文件。
  • Flask是使用jinja2引擎来渲染模板，使用模板语言，动态的设置模板文件中的内容
    1. jinja2:是python下被广泛应用的模板引擎，是python实现的模板语言，是Flask内置的模板语言。
    2. 模板语言:是一种被设计来自动生成文档的简单文本格式。在模板语言中，一般都会把一些变量传给模板，替换模板的特定位置上预先定义好的占位比变量名。如变量代码块：{{‘这里是占位的变量名’}} ；控制代码块：{%‘这里是一些控制语句’%}

渲染模板

  • 使用 render_template 函数进行渲染
  • render_template函数的第一个参数是模板的文件名，后面的参数都是键值对，表示模板中变量对应的真实值
from flask import Flask, render_template
app = Flask(__name__)

@app.route('/')
def hello_world():
    my_list = [1,2,3,4,5,6]
    my_dict = {
        'name':"michael",
        'age':18
    }
    my_dict_list = [
        {'name':'michael',"age":18},
        {'name':'jackson',"age":10}

    return render_template("demo_template.html", my_dict=my_dict,
                           my_list=my_list, my_dict_list=my_dict_list)

过滤器

  • 过滤器本质就是函数
  • 需求：有时候不仅仅是想输出变量的值，还想改变量的显示，甚至是格式化，运算等等。此时需要用到过滤器。

格式：变量名|过滤器

{{variable | filter_name(*args)}}

  • 没有参数可以写成：

{{variable | filter_name}}

过滤器支持链式调用

{{ "hello world" | reverse | upper }}

常见过滤器

字符串操作

  • safe：禁用转义

    <p>{{ '<em>hello</em>' | safe }}</p>

  • capitalize：把变量值的首字母转成大写，其余字母转小写

    <p>{{ 'hello' | capitalize }}</p>

  • lower：把值转成小写

    <p>{{ 'HELLO' | lower }}</p>

  • upper：把值转成大写

<p>{{ 'hello' | upper }}</p>

  • title：把值中的每个单词的首字母都转成大写

<p>{{ 'hello' | title }}</p>

  • reverse：字符串反转

<p>{{ 'olleh' | reverse }}</p>

  • format：格式化输出

<p>{{ '%s is %d' | format('name',17) }}</p>

  • striptags：渲染之前把值中所有的HTML标签都删掉

<p>{{ '<em>hello</em>' | striptags }}</p>

  • truncate: 字符串截断
    <p>{{ 'hello every one' | truncate(9)}}</p>
列表操作
  • first：取第一个元素

<p>{{ [1,2,3,4,5,6] | first }}</p>

  • last：取最后一个元素

<p>{{ [1,2,3,4,5,6] | last }}</p>

  • length：获取列表长度

<p>{{ [1,2,3,4,5,6] | length }}</p>

  • sum：列表求和

<p>{{ [1,2,3,4,5,6] | sum }}</p>

  • sort：列表排序

<p>{{ [6,2,3,1,5,4] | sort }}</p>

语句块过滤
{% filter upper %}
    一大堆文字
{% endfilter %}

自定义过滤器

  • 有时候，系统内置的过滤器不能满足需求，就需要自定义过滤器

  • 方法：

    • 通过add_template_filter方法
    • 通过add_template_filter装饰器（推荐使用）

  • 方式一
    通过调用应用程序实例的add_template_filter方法实现自定义过滤器。该方法第一个参数是函数名，第二个参数是自定义的过滤器名称：

def do_list_reverse(list):
    list.reverse()
    return list
app.add_template_filter(do_list_reverse, 'lsreverse')
  • 方式二
    用装饰器来实现自定义过滤器。装饰器传入的参数是自定义的过滤器名称。
@app.template_filter('lsreverse')
def do_list_reverse(list):
    list.reverse()
    return list

控制代码块

  • 模板语言的一种用法，用来执行一些控制功能。如遍历，判断等
  • 常用的有{% for x in xx %}{%endfor%}和{%if x ==2 %}{% endif %},也可以配合使用:
{% for num in my_list if num > 3 %}
    {{ num }} <br>
{% endfor %}
  • 在for 循环中可以访问一些特殊变量，如：loop.index(当前迭代的的次数)；loop.cycle(循环某几个参数值)

比如：要是我们想知道当前被迭代的元素序号，则可以使用loop变量的index属性,例如

{% for num in my_list %}
    {{ loop.index }} -
    {% if num > 3 %}
        {{ num }}
    {% endif %} <br>
{% endfor %}

假设my_list=[1, 3, 5, 7, 9]会输出这样的结果

1-
2-
3-5
4-7
5-9

cycle函数会在每次循环的时候,返回其参数中的下一个元素,可以拿上面的例子来说明:

{% for num in my_list %}
    {{ loop.cycle('a', 'b') }} -
    {{ num }} <br>
{% endfor %}

会输出这样的结果：

a-
b-
a-5
b-7
a-9
  • for循环中其他的特殊变量
    • loop.index0 当前循环迭代的次数（从 0 开始）
    • loop.revindex 到循环结束需要迭代的次数（从 1 开始）
    • loop.revindex0 到循环结束需要迭代的次数（从 0 开始）
    • loop.first 如果是第一次迭代，为 True 。
    • loop.last 如果是最后一次迭代，为 True 。
    • loop.length 序列中的项目数。

模板代码的复用

  • 有时候模板中有许多重复代码，为了精简代码，提高代码的重用性，就需要对多次重复使用的模板代码进行复用设置。
  • 复用模板的方式有三种：1.继承 2.包含 3.宏

继承

  • 在父模板里挖好坑，子模板继承，填坑

  • 父模板：base.html


{% block top %}
    <h1>这是头部内容</h1>
{% endblock %}


{% block center %}
    这是父类的中间的内容
{% endblock %}


{% block bottom %}
    <h1>这是底部内容</h1>
{% endblock %}
  • 子模板：extends 指令声明继承自拿个父模板
{% extends 'base.html' %}

{% block content %}
    {{ super() }} <br>
    需要填充的内容 <br>
{% endblock content %}
  • 注意点：
    • 不支持多继承
    • 为了便于阅读，在子模板中使用extends时，尽量写在模板的第一行。
    • 不能在一个模板文件中定义多个相同名字的block标签。
    • 当在页面中使用多个block标签时，建议给结束标签起个名字，当多个block嵌套时，阅读性更好。

包含

  • 将另一个模板整个加载到当前模板中
  • 使用include指令

{% include 'hello.html' %}

  • 注意点：
    • 如果包含的模板文件不存在时，程序会抛出TemplateNotFound异常，可以加上 ignore missing 关键字。如果包含的模板文件不存在，会忽略这条include语句。

{% include 'hello.html' ignore missing %}

宏

  • 可以理解成给模板代码抽出函数，需要时调用传参
  • 使用 macro 指令
  • 一个表单的书写，比较麻烦
<form>
    <label>用户名:</label><input type="text" name="username"><br>
    <label>昵称:</label><input type="text" name="nickname"><br>
    <label>身份证:</label><input type="text" name="idcard"><br>
    <label>密码:</label><input type="password" name="password"><br>
    <label>确认密码:</label><input type="password" name="password2"><br>
    <input type="submit" value="提交">
</form>
  • 简单点，定义宏
{% macro input(label="", type="text", name="", value="") %}
    <label>{{ label }}</label><input type="{{ type }}" name="{{ name }}" value="{{ value }}"><br>
{% endmacro %}
  • 将定义的多个宏单独放在一个文件里，如macro.html方便复用
  • 调用宏：
{% import 'macro.html' as func%}

<form>
    {{ func.input("用户名:", name="username") }}
    {{ func.input("昵称::", name="nickname") }}
    {{ func.input("身份证:", name="idcard") }}
    {{ func.input("密码:", type="password", name="password") }}
    {{ func.input("确认密码:", type="password", name="password2") }}
    {{ func.input(type="submit", value="提交") }}
</form>

总结

  • 继承(Block)、包含(include)、宏(Macro)均能实现代码的复用。

    • 继承(Block)的本质是代码替换，一般用来实现多个页面中重复不变的区域。
    • 包含(include)是直接将目标模板文件整个渲染出来。
    • 宏(Macro)的功能类似函数，可以传入参数，需要定义、调用。
VisionaryX
关注
专栏目录
菜鸡的flask模板注入
weixin_45805993的博客
10-08 692
ssti：SSTI就是服务器端模板注入(Server-Side Template Injection)，也给出了一个注入的概念，通过与服务端模板的 输入输出 交互，在过滤不严格的情况下，构造恶意输入数据，从而达到读取文件或者getshell的目的 因为flask使用Jinja2渲染引擎，可以在前端通过{{}}的形式使用变量或者{% %}执行python语句，存在注入的可能（不懂的话先去看flask！） 因为flask是用的python语言，所以python中的一些内置函数可以在flask中被使用，我们可以借
python flask body_html 字符串替换_python 全栈开发，Day119(Flask初识,Render Redirect HttpResponse,request,模板语言 Ji...
weixin_34070493的博客
02-19 430
一、Flask初识首先,要看你学没学过Django 如果学过Django 的同学,请从头看到尾,如果没有学过Django的同学,并且不想学习Django的同学,轻饶过第一部分三大主流Web框架对比1.Django 主要特点是大而全,集成了很多组件,例如: Models Admin Form 等等, 不管你用得到用不到,反正它全都有,属于全能型框架2.Tornado 主要特点是原生异步非阻塞,在IO...
Python Web框架Django 和 Flask区别及使用
justzcy的博客
04-26 7112
选择:Django和Flask是最流行的Python Web框架 Django 是一个由 Python 编写的一个开放源代码的 Web 应用框架。 使用 Django，只要很少的代码，Python 的程序开发人员就可以轻松地完成一个正式网站所需要的大部分内容，并进一步开发出全功能的 Web 服务 Django 本身基于 MVC 模型，即 Model（模型）+ View（视图）+ Controller（控制器）设计模式，MVC 模式使后续对程序的修改和扩展简化，并且使程序某一部分的重复利用成为可能。
Django和Flask区别
W2175206532的博客
06-27 4060
目录1.基本介绍与特色2.性能3.项目结构1.基本介绍与特色DjangoDjango是一个开源的Python Web应用框架，采用了MVT的框架模式，即模型M，视图V和模版T，最早于2005年发布。Django被认为是"大而全"的重量级Web框架，其自带大量的常用工具和组件（比如数据库ORM组件、用户认证、权限管理、分页、缓存), 甚至还自带了管理后台Admin，适合快速开发功能完善的企业级网站。Django自带免费的数据SQLite，同时支持MySQL与PostgreSQL等多种数据库。FlaskFlas
Django和Flask的区别
秋凉知意
03-28 7189
Django走的是大而全的方向，开发效率高。它的MTV框架，自带ORM，admin后台管理，自带的sqlite数据库和开发测试用的服务器，给开发者提高了开发效率。重量级的web框架，功能齐全，提供一站式的解决思路，能让开发者不用在选择上花费大量的时间。 自带ORM和模板引擎，支持jinja等非官方模板引擎。 自带ORM使Django和关系型数据库耦合度高，如果要使用非关系型数据库，需要使用第三方库...
Flask加盐密码生成和验证函数
01-04 1198
本文介绍Flask密码生成和密码验证的一种通用方法。所使用的函数为Flask框架内 置的函数：generate_password_hash, check_password_hash。 密码加密简介 密码存储的主要形式： 明文存储：肉眼就可以识别，没有任何安全性。 加密存储：通过一定的变换形式，使得密码原文不易被识别。 密码加密的几类方式： 明文转码加密：BASE64, 7
day053 Flask_模板，数据库
小孟先森的博客
03-24 271
当前看来Flask要比Django灵活简单许多，但是要学好，学精还是要多看，多练。 今天主要学的内容有: Flask特有的变量和函数 WTF 数据库的配置 模型类 数据库的增删改 数据库的查询 Flask特有的变量和函数 在模板中可以调用一些请求过程中生成的特有的变量和函数 它们分别是： config对象:存储应用的配置信息的。可以直接用‘.’调用某个数据 request对象：...
python flask template 模板应用
爱死亡机器人
05-14 1551
1. templates模板运用 前面介绍了创建一个hello world项目， 下面介绍模板 格式: user = {'username': 'Miguel'} 原先的视图函数返回简单的字符串，我现在要将其扩展为包含完整HTML页面元素的字符串，如下所示： $ vim app/routes.py from app import app @app.route('/') @app.route('/index') def index(): user = {'username': 'Miguel'}
Python Flask Web框架教程 2 模板
sunny_98_98的博客
01-19 236
原文 在完成第1章之后，你将拥有一个具有以下文件结构的可正常运行且简单的Web应用程序： microblog\ venv\ app\ __init__.py routes.py microblog.py 要运行该应用程序，请在终端会话中设置FLASK_APP = microblog.py，然后执行flask run。 这将使用该应用程序启动Web服务器，你可以通过在Web浏览器的地址栏中键入http://localhost:5000/ URL来打开该服务器。 在本章中，你将继续
flask学习-day1
最新发布
qq_43251445的博客
08-04 916
django是大而全，flask是轻量级的框架django提供非常多组件：orm/session/cookie/admin/form/modelform/路由/视图/模板/中间件/分页/auth/contentype/缓存/信号/多数据库连接flask本身没有太多的功能：路由/试视图/模板/session/中间件，第三方组件齐全注意：django的请求处理是逐一封装和传递；flask请求是利用上下文管理实现的
python flask项目结构规范_python 全栈开发，Day142(flask标准目录结构, flask使用SQLAlchemy,flask离线脚本,flask多app应用,flask-scr...
weixin_39630762的博客
12-16 776
昨日内容回顾1. 简述flask上下文管理-threading.local-偏函数-栈2. 原生SQL和ORM有什么优缺点？开发效率： ORM>原生SQL执行效率： 原生SQL>ORM如：SQLAlchemy依赖pymysql3. SQLAlchemy多线程连接的情况View Code一、flask标准目录结构标准flask目录结构Project name/ #项目名├── Proj...
Flask Tutorial --day1
NUNIDEcainiao的博客
08-07 387
Flask Tutorial --day1 Flask是一个使用 Python 编写的轻量级 Web 应用框架。其 WSGI 工具箱采用 Werkzeug ，模板引擎则使用 Jinja2 。Flask使用 BSD 授权。 安装 在这里我使用的anaconda 进行虚拟环境的建立，使用jupyter notebook 进行开发 安装anaconda anaconda安装教程1 anaconda安装教程2 参考这两篇应该是够用了，安装好anaconda之后我们来创建虚拟环境并配置jupyter notebook
第2天：在Flask应用中使用模板—templates
猫姐的博客
06-01 2951
原文：http://www.catonlinepy.tech/ 声明：原创不易，未经许可，不得转载 1. 你将学会什么 通过学习第二天的内容，你将会对模板有所了解，并且知道为什么要使用模板，以及使用模板有什么好处。这一天的学习内容涉及到的代码都会托管到github上，猫姐再次强调，在学习本课内容时一定要自己尝试手敲代码，遇到问题再到github上去查看代码，如果实在不知道如何去解决问题，可以在日志...
linux下 安装企业微信
小孟先森的博客
10-22 6382
以下步骤在ubuntu 18.04环境下测试 1.安装 Deepin-Wine 环境: 1.1 把 Deepin-wine-for-ubuntu Git 仓库的内容克隆到本地： git clone https://github.com/wszqkzqk/deepin-wine-ubuntu.git cd deepin-wine-ubuntu 1.2安装： chmod +x ./install_2.8.22.sh sudo ./install_2.8.22.sh 2.安装 De.
day073 项目_IT橘子爬虫
小孟先森的博客
04-26 3787
今天，做了一个爬虫的新项目——IT桔子(www.itjuzi.com/company)的信息爬取. IT桔子是关注IT互联网行业的结构化的公司数据库和商业信息提供商 IT桔子致力于通过信息和数据的生产、聚合、挖掘、加工、处理，帮助目标用户和客户节约时间和金钱、提高效率，以辅助其各类商业行为，包括风险投资、收购、竞争情报、细分行业信息、国外公司产品信息数据服务等。 所以IT桔子网...
量化交易_1
小孟先森的博客
05-26 2811
量化交易 量化交易基础 框架介绍 策略编写 量化交易基础 量化交易：量化交易是指借助现代统计学和数学方法，利用计算机技术来进行交易的证券投资方式。 量化交易的分类 按照投资技术分类 趋势性交易 市场中性 高频交易 按照金融产品分类 股票 期货 量化交易历史：产生与上世纪60年代，兴起于70-80年代，繁荣于90年代。中国因为90年代才开市，所以2010年之后才兴起起来。 量...
matplotlib.pyplot绘制不同图型&Numpy
小孟先森的博客
05-13 2052
不同的图形的应用场景 折线图 显示数据的变化，趋势 如，温度随时间的变化 plt.plot(a,b) 条形图（柱状图） 显示数据之间的大小比较 如,电影院每天排片的所有电影的票房比较 plt.bar(a,b) 直方图 反应数据在不同的范围内的分布 如，一个班级里的身高在(1.6-1.65;1.65-1.7;1.7-1.75;1.75-1.8)这几个范围内的分布 plt.hist(a...
day063 urllib2库的进阶使用及requests库的使用
小孟先森的博客
04-11 1576
urllib2 模块可以伪装成普通web客户端，发送请求，爬取数据，今天进一步了解一下这个模块的使用。如果会使用了，那就不要用它了，因为有更加简单好用的requests 模块。但是学习使用urllib2模块的使用，会加深你对爬虫过程的理解，还是要好好学。 主要内容 urllib2 get请求 json数据 一般网页都会使用ajax请求加载网页内的数据，因为可以在不用刷新网页 爬取数...
量化交易_4
小孟先森的博客
05-30 1191
概要 选股的时候需要有权重的参考来选择，所以确定权重也是最终进行选股的依据 确定权重的方法： 打分法选股策略 回归法选股策略 模拟交易 多因子策略的流程 1.准备数据，确定因子所需数据 2.单因子的有效性分析 3.多因子组合 4.确定因子权重 5.确定股票池，以排序选股 6.确定调仓周期 7.计算组合业绩 打分法选股策略 将不同股票的相同因子按照它们的升序/逆序排列起...
Flask框架项目开发的7阶段指导与实践
Python是Flask框架的运行基础，因此确保拥有最新版本的Python环境至关重要。安装Flask可以通过Python包管理器pip来完成。安装完成后，我们通常使用命令行工具创建一个新的Flask项目，这可以通过flask命令来实现。 *...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值