flask框架-大结局
flask-script
用于实现类似于django中 python3 manage.py runserver ...类似的命令。
安装
pip3 install flask-script
使用:
from flask_script import Manager
app = Flask(__name__)
manager=Manager(app)
@app.route("/")
def index()
return "hello world"
if __name__ == '__main__':
manager.run()
#以后在执行,直接:python3 manage.py runserver
#python3 manage.py runserver --help
启动服务器
自定义命令
from flask_script import Manager
from flask import Flask
# 安装pip3 install flask-script app = Flask(__name__)
manager = Manager(app) @app.route("/")
def index():
return "hello world" @manager.command
def func(arg,a):
print(arg,a) @manager.option('-n','--name',dest='name')
@manager.option('-u','--url',dest='url')
def cmd(name,url):
"""
自定义命令(-n也可以写成--name)
执行:python3 manage.py cmd -n jack -u http://www.baidu.com
执行: python manage.py cmd --name lqz --url http://www.oldboyedu.com
:param name:
:param url:
:return:
"""
print(name,url)
if __name__ == '__main__':
manager.run()
参数传参注意事项:
cmd终端输入命令:
多app应用
from werkzeug.wsgi import DispatcherMiddleware
from werkzeug.serving import run_simple
from flask import Flask, current_app
app1 = Flask('app01')
app2 = Flask('app02') @app1.route('/index')
def index():
return "app01" @app2.route('/index2')
def index2():
return "app2" # http://www.oldboyedu.com/index
# http://www.oldboyedu.com/sec/index2
dm = DispatcherMiddleware(app1, {
'/sec': app2,
}) if __name__ == "__main__":
run_simple('localhost', 5000, dm)
分析
路由的访问
.wtforms
表单验证
安装:
pip3 install wtforms
使用:
from flask import Flask, render_template, request, redirect
from wtforms import Form
from wtforms.fields import simple
from wtforms import validators
from wtforms import widgets app = Flask(__name__) app.debug = True class LoginForm(Form):
# 字段(内部包含正则表达式)
name = simple.StringField(
label='用户名',
validators=[
validators.DataRequired(message='用户名不能为空.'),
validators.Length(min=2, max=6, message='用户名长度必须大于%(min)d且小于%(max)d')
],
widget=widgets.TextInput(), # 页面上显示的插件
render_kw={'class': 'form-control'}
)
# 字段(内部包含正则表达式)
pwd = simple.PasswordField(
label='密码',
validators=[
validators.DataRequired(message='密码不能为空.'),
validators.Length(min=8, message='密码长度必须大于%(min)d'),
# validators.Regexp(regex="^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]{8,}",
# message='密码至少8个字符,至少1个大写字母,1个小写字母,1个数字和1个特殊字符') ],
widget=widgets.PasswordInput(),
render_kw={'class': 'form-control'}
) @app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'GET':
form = LoginForm()
return render_template('login.html', form=form)
else:
form = LoginForm(formdata=request.form)
if form.validate():
print('用户提交数据通过格式验证,提交的值为:', form.data)
else:
print(form.errors)
return render_template('login.html', form=form) if __name__ == '__main__':
app.run()
login.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>登录</h1>
<form method="post">
<p>{{form.name.label}} {{form.name}} {{form.name.errors[0] }}</p> <p>{{form.pwd.label}} {{form.pwd}} {{form.pwd.errors[0] }}</p>
<input type="submit" value="提交">
</form>
</body>
</html>
效果:
使用2:
邮箱,单选框,多选框,下拉选框,全局钩子校验密码的实现。
from flask import Flask, render_template, request, redirect
from wtforms import Form
from wtforms.fields import core
from wtforms.fields import html5
from wtforms.fields import simple
from wtforms import validators
from wtforms import widgets app = Flask(__name__, template_folder='templates')
app.debug = True class RegisterForm(Form): def validate_pwd_confirm(self, field):
"""
自定义pwd_confirm字段规则,例:与pwd字段是否一致
:param field:
:return:
"""
# 最开始初始化时,self.data中已经有所有的值
print(field.data)
if field.data !="sb":
#raise validators.ValidationError("sb") # 继续后续验证
raise validators.StopValidation("SB") # 不再继续后续验证 # if field.data != self.data['pwd']:
# raise validators.ValidationError("密码不一致") # 继续后续验证
#raise validators.StopValidation("密码不一致") # 不再继续后续验证 name = simple.StringField(
label='用户名',
validators=[
validators.DataRequired()
],
widget=widgets.TextInput(),
render_kw={'class': 'form-control'},
default='Eason'
) pwd = simple.PasswordField(
label='密码',
validators=[
validators.DataRequired(message='密码不能为空.')
],
widget=widgets.PasswordInput(),
render_kw={'class': 'form-control'}
) pwd_confirm = simple.PasswordField(
label='重复密码',
validators=[
validate_pwd_confirm,
validators.DataRequired(message='重复密码不能为空.'),
#validators.EqualTo('pwd', message="两次密码输入不一致")
],
widget=widgets.PasswordInput(),
render_kw={'class': 'form-control'}
)
email = html5.EmailField(
label='邮箱',
validators=[
validators.DataRequired(message='邮箱不能为空.'),
validators.Email(message='邮箱格式错误')
],
widget=widgets.TextInput(input_type='email'),
render_kw={'class': 'form-control'}
) gender = core.RadioField(
label='性别',
choices=(
(1, '男'),
(2, '女'),
),
coerce=int # “1” “2”
)
city = core.SelectField(
label='城市',
choices=(
('bj', '北京'),
('sh', '上海'),
)
) hobby = core.SelectMultipleField(
label='爱好',
choices=(
(1, '篮球'),
(2, '足球'),
),
coerce=int
) favor = core.SelectMultipleField(
label='喜好',
choices=(
(1, '篮球'),
(2, '足球'),
),
widget=widgets.ListWidget(prefix_label=False),
option_widget=widgets.CheckboxInput(),
coerce=int,
default=[1, 2]
) def __init__(self, *args, **kwargs):
super(RegisterForm, self).__init__(*args, **kwargs)
self.favor.choices = ((1, '篮球'), (2, '足球'), (3, '羽毛球'))
self.favor.data=[1,] @app.route('/register', methods=['GET', 'POST'])
def register():
if request.method == 'GET':
form = RegisterForm(data={'gender': 2,'hobby':[1,]}) # initial
return render_template('register.html', form=form)
else:
form = RegisterForm(formdata=request.form)
if form.validate():
print('用户提交数据通过格式验证,提交的值为:', form.data)
else:
print(form.errors)
return render_template('register.html', form=form) if __name__ == '__main__':
app.run()
register.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>用户注册</h1>
<form method="post" novalidate style="padding:0 50px">
{% for field in form %}
<p>{{field.label}}: {{field}} {{field.errors[0] }}</p>
{% endfor %}
<input type="submit" value="提交">
</form>
</body>
</html>
前台渲染效果
.SQLALlchemy
学习内容:
1、介绍
2、简单使用(能创建表,删除表,不能修改表)
3、一对多的关系
4、多对多关系
5、操作数据表
6、基于scoped_session实现线程安全
7、基本的增删改查
8、常用的操作
9、执行原生的mysql
10、一对多
11、多对多
12、Flask-SQLAlchemy
介绍
SQLAlchemy是一个基于Python实现的ORM框架。该框架建立在 DB API之上,使用关系对象映射进行数据库操作,
简言之便是:将类和对象转换成SQL,然后使用数据API执行SQL并获取执行结果。
安装
pip3 install sqlalchemy
重要的参数说明
#Engine,框架的引擎
#Connection Pooling ,数据库连接池
#Dialect,选择连接数据库的DB API种类
#Schema/Types,架构和类型
#SQL Exprression Language,SQL表达式语言
SQLAlchemy本身无法操作数据库,其必须以来pymsql等第三方插件,Dialect用于和数据API进行交流,
根据配置文件的不同调用不同的数据库API,从而实现对数据库的操作,如:
MySQL-Python
mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname> pymysql
mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>] MySQL-Connector
mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
1、简单使用(能创建表,删除表,不能修改表)
执行原生sql(不常用)
import time
import threading
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.engine.base import Engine engine = create_engine(
"mysql+pymysql://root:123456@127.0.0.1:3306/test?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间,否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收(重置)
)
def task(arg):
conn = engine.raw_connection()
cursor = conn.cursor()
cursor.execute(
"select * from app01_book"
)
result = cursor.fetchall()
print(result)
cursor.close()
conn.close() for i in range(20):
t = threading.Thread(target=task, args=(i,))
t.start()
orm使用
models.py
import datetime
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
from sqlalchemy.orm import relationship
Base = declarative_base() class Users(Base):
__tablename__ = 'users' # 数据库表名称
id = Column(Integer, primary_key=True) # id 主键
name = Column(String(32), index=True, nullable=False) # name列,索引,不可为空
#email = Column(String(32), unique=True)
age = Column(Integer,default=0)
#datetime.datetime.now不能加括号,加了括号,以后永远是当前时间
#ctime = Column(DateTime, default=datetime.datetime.now)
#extra = Column(Text, nullable=True) # __table_args__ = (
# UniqueConstraint('id', 'name', name='uix_id_name'), #联合唯一
# Index('ix_id_name', 'name', 'email'), #索引
# )
def __repr__(self):
return self.name class Hobby(Base):
__tablename__ = 'hobby'
id = Column(Integer, primary_key=True)
caption = Column(String(50), default='篮球') class Person(Base):
__tablename__ = 'person'
nid = Column(Integer, primary_key=True)
name = Column(String(32), index=True, nullable=True)
# hobby指的是tablename而不是类名,
hobby_id = Column(Integer, ForeignKey("hobby.id"))
# 跟数据库无关,不会新增字段,只用于快速链表操作
# 类名,backref用于反向查询,uselist=False
hobby = relationship('Hobby', backref='pers')
def __repr__(self):
return self.name class Boy2Girl(Base):
__tablename__ = 'boy2girl'
id = Column(Integer, primary_key=True, autoincrement=True)
girl_id = Column(Integer, ForeignKey('girl.id'))
boy_id = Column(Integer, ForeignKey('boy.id')) class Girl(Base):
__tablename__ = 'girl'
id = Column(Integer, primary_key=True)
name = Column(String(64), unique=True, nullable=False) class Boy(Base):
__tablename__ = 'boy' id = Column(Integer, primary_key=True, autoincrement=True)
hostname = Column(String(64), unique=True, nullable=False) # 与生成表结构无关,仅用于查询方便,放在哪个单表中都可以
girl = relationship('Girl', secondary='boy2girl', backref='boys') def init_db():
"""
根据类创建数据库表
:return:
"""
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/flask?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间,否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收(重置)
) Base.metadata.create_all(engine) def drop_db():
"""
根据类删除数据库表
:return:
"""
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/flask?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间,否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收(重置)
) Base.metadata.drop_all(engine) if __name__ == '__main__':
#drop_db()
init_db()
app.py
操作数据库
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import Users
#"mysql+pymysql://root@127.0.0.1:3306/aaa"
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/flask", max_overflow=0, pool_size=5)
Connection = sessionmaker(bind=engine) # 每次执行数据库操作时,都需要创建一个Connection
con = Connection() # ############# 执行ORM操作 #############
obj1 = Users(name="jack",age=20)
con.add(obj1)
# 提交事务
con.commit() # 关闭session,其实是将连接放回连接池
con.close()
基于scoped_session实现线程安全
关于数据库连接时每次都要提交commint带来的线程安全问题
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session
from models import Users engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/flask", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine) """
# 线程安全,基于本地线程实现每个线程用同一个session
# 特殊的:scoped_session中有原来方法的Session中的一下方法: public_methods = (
'__contains__', '__iter__', 'add', 'add_all', 'begin', 'begin_nested',
'close', 'commit', 'connection', 'delete', 'execute', 'expire',
'expire_all', 'expunge', 'expunge_all', 'flush', 'get_bind',
'is_modified', 'bulk_save_objects', 'bulk_insert_mappings',
'bulk_update_mappings',
'merge', 'query', 'refresh', 'rollback',
'scalar'
)
"""
#scoped_session类并没有继承Session,但是却又它的所有方法
session = scoped_session(Session)
# ############# 执行ORM操作 #############
obj1 = Users(name="jason")
session.add(obj1) # 提交事务
session.commit()
# 关闭session
session.close()
单表操作,简单的增删改查
import time
import threading
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text from models import Users
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/flask", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine) session = Session() # ################ 添加 ################
# obj1 = Users(name="Eason",age=20)
# session.add(obj1)
#
# # session.add_all([
# # Users(name="tank"),
# # Users(name="jason"),
# # #Hosts(name="c1.com"),
# ])
# session.commit() # ################ 删除 ################
# session.query(Users).filter(Users.id == 5).delete()
# session.commit()
# ################ 修改 ################ #传字典
#session.query(Users).filter(Users.id ==4 ).update({"age" : 30,})
#类似于django的F查询
#session.query(Users).filter(Users.id == 3).update({Users.name: Users.name + "sb"}, synchronize_session=False)
#session.query(Users).filter(Users.id == 7).update({"age": Users.age + 16}, synchronize_session="evaluate")
# session.commit() # ################ 查询 ################ # r1 = session.query(Users).all()
# print(r1)
#只取age列,把name重命名为xx
# r2 = session.query(Users.name.label('sb'), Users.age).filter(Users.id==8).first()
# print(r2.sb)
#filter传的是表达式,filter_by传的是参数
# r3 = session.query(Users).filter(Users.name == "jason").all()
# print(r3)
# r4 = session.query(Users).filter_by(name='jason').all()
# print(r4)
# r5 = session.query(Users).filter_by(name='lqz').first()
#:value 和:name 相当于占位符,用params传参数
#r6 = session.query(Users).filter(text("id<:value and name=:name")).params(value=224, name='fred').order_by(Users.id).all()
#自定义查询sql
#r7 = session.query(Users).from_statement(text("SELECT * FROM users where name=:name")).params(name='ed').all() #增,删,改都要commit()
session.close()
一对多关系
import time
import threading from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text
from sqlalchemy.engine.result import ResultProxy
from models import Users, Hobby, Person engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/flask?charset=utf8", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session = Session()
# 添加 # session.add_all([
# Hobby(caption='乒乓球'),
# Hobby(caption='羽毛球'),
# Person(name='张三', hobby_id=1),
# Person(name='李四', hobby_id=2),
# ]) # person = Person(name='张九', hobby=Hobby(caption='姑娘'))
# session.add(person)
#添加二
# hb = Hobby(caption='人妖')
# hb.pers = [Person(name='文飞'), Person(name='博雅')]
# session.add(hb)
#
# session.commit()
""" # 使用relationship正向查询
"""
# v = session.query(Person).first()
# print(v.name)
# print(v.hobby.caption)
""" # 使用relationship反向查询
"""
# v = session.query(Hobby).first()
# print(v.caption)
# print(v.pers) #方式一,自己链表
# person_list=session.query(Person).join(Hobby,isouter=True)
# print(person_list)
# person_list=session.query(Person,Hobby).join(Hobby,isouter=True)
# print(person_list)
# for row in person_list:
# # print(row.name,row.caption)
# print(row[0].name,row[1].caption)
#
# #方式二:通过relationship
#
person_list=session.query(Person).all()
for row in person_list:
print(row.name,row.hobby.caption)
# #查询喜欢姑娘的所有人
# obj=session.query(Hobby).filter(Hobby.id==1).first()
# persons=obj.pers
# print(persons)
# session.close()
#如果没有建立外键 # ret = session.query(Person).join(Hobby,Person.nid==Hobby.id, isouter=True)
# print(ret)
多对多关系
import time
import threading from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text
from sqlalchemy.engine.result import ResultProxy
from models import Users, Hobby, Person, Girl, Boy2Girl, Boy engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/flask?charset=utf8", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session = Session()
# 添加
# session.add_all([
# Girl(name='c1.com'),
# Girl(name='c2.com'),
# Boy(hostname='A组'),
# Boy(hostname='B组'),
# ])
# session.commit() # s2g = Boy2Girl(girl_id=1,boy_id=1)
# session.add(s2g)
# session.commit()
#
# gp = Girl(name='C组')
# gp.boys = [Boy(hostname='c3.com'),Boy(hostname='c4.com')]
# session.add(gp)
# session.commit()
#
# ser = Boy(hostname='c6.com')
# ser.girl = [Girl(name='F组'),Girl(name='G组')]
# session.add(ser)
# session.commit() # 使用relationship正向查询 # v = session.query(Boy).first()
# print(v.hostname)
# print(v.girl) # 使用relationship反向查询 # v = session.query(Girl).first()
# print(v.name)
# print(v.boys) # session.close()
Flask-SQLAlchemy
flask和SQLAchemy的管理者,通过它吧他们连接起来。
flask多依赖于第三方软件,想使用就先安装:
安装:
pip3 install flask-sqlalchemy/flask-migrate
项目结构:
重要参数:
"""
db = SQLAlchemy()
- 包含配置
- 包含ORM基类
- 包含create_all
- engine
- 创建连接 """
通过配置设置实现和Django一样,可以用命令makegirations来迁移数据库数据。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
class BaseConfig(object):
# SESSION_TYPE = 'redis' # session类型为redis
# SESSION_KEY_PREFIX = 'session:' # 保存到session中的值的前缀
# SESSION_PERMANENT = True # 如果设置为False,则关闭浏览器session就失效。
# SESSION_USE_SIGNER = False # 是否对发送到浏览器上 session:cookie值进行加密
SQLALCHEMY_DATABASE_URI = "mysql+pymysql://root:123@127.0.0.1:3306/flask01?charset=utf8"
SQLALCHEMY_POOL_SIZE = 5
SQLALCHEMY_POOL_TIMEOUT = 30
SQLALCHEMY_POOL_RECYCLE = -1 # 追踪对象的修改并且发送信号
SQLALCHEMY_TRACK_MODIFICATIONS = False class ProductionConfig(BaseConfig):
pass class DevelopmentConfig(BaseConfig):
pass class TestingConfig(BaseConfig):
pass
操作区别
flask-migrate
#python3 manage.py db init 初始化:只执行一次 #python3 manage.py db migrate 等同于 makemigartions
#python3 manage.py db upgrade 等同于migrate
__repr__()
是一个非常特殊的方法,它是一个“自我描述”的方法,
该方法通常用于实现这样一个功能:当程序员直接打印该对象时,
系统将会输出该对象的“自我描述”信息,
用来告诉外界该对象具有的状态信息。
flask框架-大结局的更多相关文章
- Flask框架简介,常用扩展包及两大核心
Flask诞生于2010年,是Armin ronacher(人名)用 Python 语言基于 Werkzeug 工具箱编写的轻量级Web开发框架. Flask 本身相当于一个内核,其他几乎所有的功能都 ...
- Flask框架搭建一个日程表
目录 前言 项目介绍 技术栈 Flask Web开发流程 一.搭建环境 1.1: 创建虚拟环境 1.2: 安装依赖包 1.3: 创建依赖包列表文件 1.4: 测试hello word 二.应用程序开发 ...
- Flask框架基础--第一篇
1.flask框架和其他几种框架的优缺点对比 Django : 优点 - 大而全所有组件都是有组织内部开发高度定制化 教科书级别的框架 缺点 - 大到浪费资源,请求的时候需要的资源较高 Flask : ...
- Python Flask框架
Python有很多Web框架,可谓是百家争鸣,我这里列出几个比较叼的几个框架 Django 市场占有率最高,官方文档几近完美,但是适合比较大的项目,小项目会显得累赘. Tornado ...
- flask框架----flask-session组件
简介 flask-session是flask框架的session组件,由于原来flask内置session使用签名cookie保存,该组件则将支持session保存到多个地方,如: redis:保存数 ...
- flask框架预备知识
1.web预备知识 2.flask介绍 3.web框架的本质及分类 4.flask安装与基本设置 1.web预备知识 HTTP协议:https://www.cnblogs.com/wyb666/p/9 ...
- flask框架的学习
---恢复内容开始--- 第一个flask程序讲解:1. 第一次创建项目的时候,要添加flask的虚拟环境.添加虚拟环境的时候,一定要选择到python这个执行文件.比如你的flask的虚拟环境的目录 ...
- flask框架基本使用(2)(响应与重定向)
#转载请留言联系 flask 框架基本使用(1):https://www.cnblogs.com/chichung/p/9756935.html 1. flask 自定义返回状态码与响应头 from ...
- Flask框架的学习与实战(二):实战小项目
昨天写了一篇flask开发环境搭建,今天继续,进行一个实战小项目-blog系统. blog系统很简单,只有一个页面,然而麻雀虽小五脏俱全.这里目的不是为了做项目而做项目,这篇文章本意是通过这次练习传达 ...
随机推荐
- 在Centos安装redis-孙志奇
最近在阿里云服务器上部署redis,遇到了很多的问题,经过不懈的努力终于配置成功, 按照下面的步骤一步一步来就好了 wget http://download.redis.io/releases/red ...
- 吴裕雄--天生自然C++语言学习笔记:C++ 数据抽象
数据抽象是指,只向外界提供关键信息,并隐藏其后台的实现细节,即只表现必要的信息而不呈现细节. 数据抽象是一种依赖于接口和实现分离的编程(设计)技术. 它们向外界提供了大量用于操作对象数据的公共方法,也 ...
- vue坑 - vue安装vue-cli报错coffee-script@1.12.7: CoffeeScript on NPM has moved to "coffeescript" (no hyphen)或者说不支
$ npm install -g vue-cli npm WARN deprecated coffee-script@1.12.7: CoffeeScript on NPM has moved to ...
- tensorflow--保存加载模型
s=mnist.train.next_batch(batch_size)print(xs.shape)print(ys.shape) # #从集合中取全部变量# tf.get_collection() ...
- 关于SI4432的问题简单讲解
对于SX1278 和SI4432的对比性,下面为大家展示对比参数: 由此可以看出的SI4432虽然跟SX1278有部分地方不同,但是整体来说还是差别不大,各有各的长处和短处,性价比上个人还是觉得SI4 ...
- mysql字符串操作
https://h.w.com/lin/h ) 效果: https://h.w.com huangwanlin ) 效果: huang huangwanlin ) 效果: wanlin huangxi ...
- TP中统计指定字段的总数
如统计已激活设备数量和未激活设备数量 $condition = [ ['member_id', '=', $member_id] ]; $field = [ 'COUNT(IF(active_memb ...
- 六、SAP中以一个变量的形式来定义另一种变量
一.代码如下: 二.输出
- centos 制作指定需求命令的YUM源
场景: 没有YUM源,但是需要安装一些用到的命令,如vim,telnet等少量命令,不想YUM源太大,满足需求即可.于是制作一个仅需要满足要求的yum源 步骤一: 联网环境下安装createreo命令 ...
- Flink并行度
并行执行 本节介绍如何在Flink中配置程序的并行执行.FLink程序由多个任务(转换/操作符.数据源和sinks)组成.任务被分成多个并行实例来执行,每个并行实例处理任务的输入数据的子集.任务的并行 ...