common/models/pay/PayOrder.py
# coding: utf-8
from app import db, app
from sqlalchemy import BigInteger, Column, DateTime, Index, Integer, Numeric, String, Text
from sqlalchemy.schema import FetchedValue
class PayOrder(db.Model):
__tablename__ = 'pay_order'
__table_args__ = (
db.Index('idx_member_id_status', 'member_id', 'status'),
)
id = db.Column(db.Integer, primary_key=True)
order_sn = db.Column(db.String(40), nullable=False, unique=True, server_default=db.FetchedValue(), info='随机订单号')
member_id = db.Column(db.BigInteger, nullable=False, server_default=db.FetchedValue(), info='会员id')
total_price = db.Column(db.Numeric(10, 2), nullable=False, server_default=db.FetchedValue(), info='订单应付金额')
yun_price = db.Column(db.Numeric(10, 2), nullable=False, server_default=db.FetchedValue(), info='运费金额')
pay_price = db.Column(db.Numeric(10, 2), nullable=False, server_default=db.FetchedValue(), info='订单实付金额')
pay_sn = db.Column(db.String(128), nullable=False, server_default=db.FetchedValue(), info='第三方流水号')
prepay_id = db.Column(db.String(128), nullable=False, server_default=db.FetchedValue(), info='第三方预付id')
note = db.Column(db.Text, nullable=False, info='备注信息')
status = db.Column(db.Integer, nullable=False, server_default=db.FetchedValue(), info='1：支付完成 0 无效 -1 申请退款 -2 退款中 -9 退款成功 -8 待支付 -7 完成支付待确认')
express_status = db.Column(db.Integer, nullable=False, server_default=db.FetchedValue(), info='快递状态，-8 待支付 -7 已付款待发货 1：确认收货 0：失败')
express_address_id = db.Column(db.Integer, nullable=False, server_default=db.FetchedValue(), info='快递地址id')
express_info = db.Column(db.String(1000), nullable=False, server_default=db.FetchedValue(), info='快递信息')
comment_status = db.Column(db.Integer, nullable=False, server_default=db.FetchedValue(), info='评论状态')
pay_time = db.Column(db.DateTime, nullable=False, server_default=db.FetchedValue(), info='付款到账时间')
updated_time = db.Column(db.DateTime, nullable=False, server_default=db.FetchedValue(), info='最近一次更新时间')
created_time = db.Column(db.DateTime, nullable=False, server_default=db.FetchedValue(), info='插入时间')
# @property 是一个装饰器，用于定义类的属性。在你供的代码中，@property 被用来定义了一个名为 pay_status 的属性。这个属性的值是通过计算得到的。
@property
def pay_status(self):
# 首先，将 self.status 赋值给 tmp_status。
tmp_status = self.status
# 根据不同的条件对 tmp_status 进行修改
if self.status == 1:
tmp_status = self.express_status
if self.express_status == 1 and self.comment_status == 0:
tmp_status = -5
if self.express_status == 1 and self.comment_status == 1:
tmp_status = 1
#最后，返回 tmp_status 的值作为 pay_status 的值
return tmp_status
# @property是Python中的一个装饰器，用于将一个方法转换为属性。
@property
# status_desc方法被@property装饰，它将status_desc方法转换为一个只读属性。
def status_desc(self):
# 当你访问status_desc属性时，它会返回app.config[‘PAY_STATUS_DISPLAY_MAPPING’][str(self.pay_status)]的值。
return app.config['PAY_STATUS_DISPLAY_MAPPING'][str(self.pay_status)]
# order_number方法也被@property装饰，将order_number方法转换为一个只读属性。
@property
def order_number(self):
# 当你访问order_number属性时，它会根据一定的规则生成一个订单号，并返回该订单号。
order_number = self.created_time.strftime("%Y%m%d%H%M%S")
order_number = order_number + str(self.id).zfill(5)
return order_number
# 这样使用@property装饰器可以使得这两个方法像属性一样被访问，而不需要使用括号调用方法
# .zfill(5)是Python中的一个字符串方法，它用于在字符串的左侧填充0，使字符串的总长度达到指定的宽度。
# 如果字符串的长度已经大于或等于指定的宽度，则不会进行任何填充。
#
# 例如，如果我们有一个字符串"123"，使用.zfill(5)方法后，它将被填充为"00123"，总长度为5。
#
# 这个方法非常适用于需要保持字符串长度一致的情况，比如在生成文件名或者格式化输出时。web/controllers/api/My.py
# -*- coding: utf-8 -*-
from web.controllers.api import route_api
from flask import request, jsonify,g
from common.models.food.Food import Food
from app import app,db
from common.models.pay.PayOrder import PayOrder
from common.models.pay.PayOrderItem import PayOrderItem
from common.libs.UrlManager import UrlManager
from common.libs.Helper import selectFilterObj,getDictFilterField,getCurrentDate
from common.models.member.MemberComments import MemberComments
import json,datetime
@route_api.route("/my/order")
def myOrderList():
resp = {'code': 200, 'msg': '操作成功~', 'data': {}}
member_info = g.member_info
req = request.values
status = int( req['status'] ) if 'status' in req else 0
query = PayOrder.query.filter_by( member_id = member_info.id )
if status == -8 :#等待付款
query = query.filter( PayOrder.status == -8 )
elif status == -7:#待发货
query = query.filter( PayOrder.status == 1,PayOrder.express_status == -7,PayOrder.comment_status == 0 )
elif status == -6:#待确认
query = query.filter(PayOrder.status == 1, PayOrder.express_status == -6,PayOrder.comment_status == 0)
elif status == -5:#待评价
query = query.filter(PayOrder.status == 1, PayOrder.express_status == 1,PayOrder.comment_status == 0)
elif status == 1:#已完成
query = query.filter(PayOrder.status == 1, PayOrder.express_status == 1,PayOrder.comment_status == 1 )
else:
query = query.filter( PayOrder.status == 0 )
pay_order_list = query.order_by( PayOrder.id.desc() ).all()
data_pay_order_list = []
if pay_order_list:
pay_order_ids = selectFilterObj( pay_order_list,"id" )
pay_order_item_list = PayOrderItem.query.filter( PayOrderItem.pay_order_id.in_( pay_order_ids ) ).all()
food_ids = selectFilterObj( pay_order_item_list,"food_id" )
food_map = getDictFilterField( Food,Food.id,"id",food_ids )
pay_order_item_map = {}
if pay_order_item_list:
for item in pay_order_item_list:
if item.pay_order_id not in pay_order_item_map:
pay_order_item_map[ item.pay_order_id ] = []
tmp_food_info = food_map[ item.food_id ]
pay_order_item_map[item.pay_order_id].append({
'id':item.id,
'food_id':item.food_id,
'quantity':item.quantity,
'price':str( item.price ),
'pic_url':UrlManager.buildImageUrl( tmp_food_info.main_image ),
'name':tmp_food_info.name
})
for item in pay_order_list:
tmp_data = {
'status':item.pay_status,
'status_desc':item.status_desc,
'date':item.created_time.strftime("%Y-%m-%d %H:%M:%S"),
'order_number':item.order_number,
'order_sn':item.order_sn,
'note':item.note,
'total_price':str( item.total_price ),
'goods_list':pay_order_item_map[ item.id ]
}
data_pay_order_list.append( tmp_data )
resp['data']['pay_order_list'] = data_pay_order_list
return jsonify(resp)
@route_api.route("/my/order/info")
def myOrderInfo():
resp = {'code': 200, 'msg': '操作成功~', 'data': {}}
member_info = g.member_info
req = request.values
order_sn = req['order_sn'] if 'order_sn' in req else ''
pay_order_info = PayOrder.query.filter_by( member_id=member_info.id ,order_sn = order_sn).first()
if not pay_order_info:
resp['code'] = -1
resp['msg'] = "系统繁忙，请稍后再试~~"
return jsonify(resp)
express_info = {}
if pay_order_info.express_info:
express_info = json.loads( pay_order_info.express_info )
tmp_deadline = pay_order_info.created_time + datetime.timedelta(minutes=30)
info = {
"order_sn":pay_order_info.order_sn,
"status":pay_order_info.pay_status,
"status_desc":pay_order_info.status_desc,
"pay_price":str( pay_order_info.pay_price),
"yun_price":str( pay_order_info.yun_price),
"total_price":str( pay_order_info.total_price),
"address":express_info,
"goods": [],
"deadline":tmp_deadline.strftime("%Y-%m-%d %H:%M")
}
pay_order_items = PayOrderItem.query.filter_by( pay_order_id = pay_order_info.id ).all()
if pay_order_items:
food_ids = selectFilterObj( pay_order_items , "food_id")
food_map = getDictFilterField(Food, Food.id, "id", food_ids)
for item in pay_order_items:
tmp_food_info = food_map[item.food_id]
tmp_data = {
"name": tmp_food_info.name,
"price": str( item.price ),
"unit": item.quantity,
"pic_url": UrlManager.buildImageUrl( tmp_food_info.main_image ),
}
info['goods'].append( tmp_data )
resp['data']['info'] = info
return jsonify(resp)
@route_api.route("/my/order")
def myOrderList():
然后通过查询数据库中的PayOrderItem表，获取满足条件PayOrderItem.pay_order_id.in_(pay_order_ids)的所有结果，将其赋值给变量pay_order_item_list。
接着，从pay_order_item_list中提取出"food_id"字段的值，将其赋值给变量food_ids。
最后，通过调用getDictFilterField函数，根据Food表的"id"字段和food_ids列表，获取到对应的字典映射关系，将其赋值给变量food_map。
问题： 实际参数显示
print('***********pay_order_ids',pay_order_ids)
print('*****************pay_order_item_list',pay_order_item_list)
print('***************food_ids',food_ids)
print('**************food_map',food_map)***********pay_order_ids [5]
*****************pay_order_item_list [<PayOrderItem 5>]
***************food_ids [2]
**************food_map {2: <Food 2>}
如图点击马上付款后出现了相关的值。
心结： 上午和昨天用人工的方式去琢磨每个值到底是什么，每个元素从哪取值，从蒙圈到懂了点什么但还是蒙圈，直接索性print一下看一下是什么值，也是别有一番乐趣。//嘿嘿。。
问题：已知PayOrderItem是各数据库，[ < PayOrderItem5 >] 是什么
PayOrderItem是一个数据库表，[ < PayOrderItem5 >] 可能是该表中的某个记录或者某个字段的值。具体来说，[ < PayOrderItem5 >] 可能是PayOrderItem表中的第5条记录，或者是PayOrderItem表中某个字段的值为5的记录。需要更多上下文信息才能确定[ < PayOrderItem5 >] 的具体含义。
问题： [ < PayOrderItem5 >] 是PayOrderItem表中的第5条记录， 请问[]是什么意思 <>又是什么意思，这两个符号起着什么作用
[ < PayOrderItem5 >] 可能是指PayOrderItem表中的第5条记录。
方括号 [] 表示其中的内容是一个标识符或者一个变量，用于表示具体的值或者对象。
尖括号 <> 则表示其中的内容是一个占位符，用于表示某个特定类型或者实例。在这个例子中，<> 可能用于表示PayOrderItem表中的记录的类型或者属性。
这两个符号在编程中起到了标识和占位的作用，用于表示不同的含义和用途。
问题：已知Food是一个数据库，Food2是Food数据库里的第二条数据，{2: < Food2 >}请问第一个2是什么作用，：又是什么作用，{}又是什么作用
在这个上下文中，{2: < Food2 >} 是一个字典（Dictionary）数据结构。字典是Python中的一种数据类型，它由键（Key）和值（Value）组成的键值对集合。
在这个字典中，键是2，值是<Food2>。键可以是任何不可变的数据类型，如整数、字符串等。值可以是任何数据类型，包括对象、列表、字典等。
第一个2作为键，用于唯一标识这个键值对。通过键，我们可以在字典中快速查找对应的值。
冒号（:）用于分隔键和值。
{} 是用来表示一个空字典或者创建一个字典的语法。在这个例子中，{} 表示创建了一个空字典，并且后续通过赋值操作将键值对添加到字典中。
问题: py中某个列表的键名的值怎么表示
在Python中，列表是一种有序的可变容器，其中的元素可以通过索引访问。列表的键名并不是一个合适的术语，因为列表中的元素是通过索引而不是键名来访问的。
要访问列表中的元素值，可以使用索引操作符[]，将要访问的元素的索引放在方括号内。索引从0开始，表示列表中的第一个元素，依次递增。
以下是一个示例，展示如何访问列表中的元素值：
my_list = ['apple', 'banana', 'orange']
print(my_list[0]) # 输出：'apple'
print(my_list[1]) # 输出：'banana'
print(my_list[2]) # 输出：'orange'mina/pages/my/order_list.js
var app = getApp();
Page({
data: {
order_list:[],
statusType: ["待付款", "待发货", "待确认", "待评价", "已完成","已关闭"],
status:[ "-8","-7","-6","-5","1","0" ],
currentType: 0,
tabClass: ["", "", "", "", "", ""]
},
statusTap: function (e) {
var curType = e.currentTarget.dataset.index;
this.setData({
currentType: curType
});
this.getPayOrder();
},
orderDetail: function (e) {
wx.navigateTo({
url: "/pages/my/order_info?order_sn=" + e.currentTarget.dataset.id
})
},
onLoad: function (options) {
// 生命周期函数--监听页面加载
},
onShow: function () {
this.getPayOrder();
},
orderCancel:function( e ){
this.orderOps( e.currentTarget.dataset.id,"cancel","确定取消订单？" );
},
getPayOrder:function(){
var that = this;
wx.request({
url: app.buildUrl("/my/order"),
header: app.getRequestHeader(),
data: {
status: that.data.status[ that.data.currentType ]
},
success: function (res) {
var resp = res.data;
if (resp.code != 200) {
app.alert({"content": resp.msg});
return;
}
that.setData({
order_list:resp.data.pay_order_list
});
}
});
},
toPay:function( e ){
var that = this;
// 使用微信小程序的wx.request方法发送一个POST请求，并在请求成功后进行支付操作
// 使用wx.request方法发送POST请求，请求的URL是"/order/pay"，并且设置请求头为app.getRequestHeader()方法返回的值
wx.request({
url: app.buildUrl("/order/pay"),
header: app.getRequestHeader(),
method: 'POST',
data: {
order_sn: e.currentTarget.dataset.id
},
// 如果请求成功，会执行success回调函数。在回调函数中，首先获取返回数据res.data，并将其赋值给变量resp。
success: function (res) {
var resp = res.data;
// 判断resp.code是否等于200，如果不等于200，则调用app.alert方法弹出提示框，并返回。
if (resp.code != 200) {
app.alert({"content": resp.msg});
return;
}
// 如果resp.code等于200，则从resp.data中获取pay_info，并将其赋值给变量pay_info。
var pay_info = resp.data.pay_info;
// 使用wx.requestPayment方法进行支付操作，传入参数包括时间戳、随机字符串、package、签名类型和支付签名。
wx.requestPayment({
'timeStamp': pay_info.timeStamp,
'nonceStr': pay_info.nonceStr,
'package': pay_info.package,
'signType': 'MD5',
'paySign': pay_info.paySign,
// 如果支付成功，会执行success回调函数；如果支付失败，会执行fail回调函数。
'success': function (res) {
},
'fail': function (res) {
}
});
}
});
},
orderConfirm:function( e ){
this.orderOps( e.currentTarget.dataset.id,"confirm","确定收到？" );
},
orderComment:function( e ){
wx.navigateTo({
url: "/pages/my/comment?order_sn=" + e.currentTarget.dataset.id
});
},
orderOps:function(order_sn,act,msg){
var that = this;
var params = {
"content":msg,
"cb_confirm":function(){
wx.request({
url: app.buildUrl("/order/ops"),
header: app.getRequestHeader(),
method: 'POST',
data: {
order_sn: order_sn,
act:act
},
success: function (res) {
var resp = res.data;
app.alert({"content": resp.msg});
if ( resp.code == 200) {
that.getPayOrder();
}
}
});
}
};
app.tip( params );
}
});
问题： 该段代码中data的作用是什么？ 是一开始 页面就拥有data里面的这些值吗？ 然后 后面使用这些值进行其他的操作设置吗
在这段代码中，data是一个对象，用于存储页面的数据。它包含了多个属性，其中每个属性都对应一个值。这些值可以在页面中进行使用和操作。
在页面一开始加载时，data中的属性和对应的初始值会被初始化。这些初始值可以在页面渲染时直接使用，也可以在后续的操作中进行修改和更新。
在后续的操作中，可以通过修改data中的属性值来实现对页面数据的更新和改变。例如，可以通过修改currentType属性的值来切换不同的状态类型，从而改变页面展示的内容。
问题： statusTap: function (e) {
var curType = e.currentTarget.dataset.index;
定义和用法：
currentTarget 事件属性返回其监听器触发事件的节点，即当前处理该事件的元素、文档或窗口。
在捕获和起泡阶段，该属性是非常有用的，因为在这两个节点，它不同于 target 属性。
语法：
event.currentTarget
问题： currentTarget.dataset.index; 中的dataset 是什么？
在JavaScript中，dataset是一个DOMStringMap对象，它是HTMLElement的属性。它允许您访问元素的自定义数据属性（data-*）。
在给定的例子中，currentTarget.dataset.index表示当前事件的目标元素的data-index属性的值。通过dataset属性，您可以轻松地访问和操作HTML元素上的自定义数据属性。
问题： 如何使用dataset属性获取自定义数据属性的值？
要使用dataset属性获取自定义数据属性的值，你需要按照步骤进行操作：
-
首先，确保你已经创建了一个数据集对象。你可以使用tf.data.Dataset.from_tensor_slices()方法来创建一个数据集对象，该方法接受一个张量作为输入，并将其切片为多个元素。
-
接下来，你可以使用.map()方法来对数据集中的每个元素应用一个函数。在这个函数中，你可以访问每个元素的自定义数据属性，并将其提取出来。
-
在函数中，你可以使用element.get()方法来获取自定义数据属性的值。该方法接受一个字符串参数，表示要获取的属性的名称。
-
最后，你可以使用.batch()方法来将数据集分批处理，以便更高效地处理大量数据。
下面是一个示例代码，演示了如何使用dataset属性获取自定义数据属性的值：
import tensorflow as tf
# 创建一个包含自定义数据属性的数据集
data = [{'image': 'image1.jpg', 'label': 0},
{'image': 'image2.jpg', 'label': 1},
{'image': 'image3.jpg', 'label': 0}]
# 创建数据集对象
dataset = tf.data.Dataset.from_tensor_slices(data)
# 定义一个函数来获取自定义数据属性的值
def get_label(element):
return element.get('label')
# 使用.map()方法应用函数并获取自定义数据属性的值
dataset = dataset.map(lambda x: tf.py_function(get_label, [x], tf.int32))
# 打印数据集中的元素
for element in dataset:
print(element.numpy())
# 使用.batch()方法分批处理数据集
batched_dataset = dataset.batch(2)
# 打印分批处理后的数据集
for batch in batched_dataset:
print(batch.numpy())这样，你就可以使用dataset属性获取自定义数据属性的值了。
var curType = e.currentTarget.dataset.index;
this.setData({
currentType: curType
});数据监听器支持监听属性或内部数据的变化，可以同时监听多个。一次 setData 最多触发每个监听器一次。
common/libs/Helper.py
'''
根据某个字段获取一个dic出来
'''
# 这是一个名为getDictFilterField的函数，它接受四个参数：db_model、select_field、key_field和id_list。
# 该函数的作用是从数据库中获取符合条件的数据，并将其转换为字典形式返回。
def getDictFilterField( db_model,select_filed,key_field,id_list ):
# 首先，创建一个空字典ret，用于存储查询结果。
ret = {}
# 接着，通过db_model.query获取数据库查询对象。
query = db_model.query
# 如果id_list不为空且长度大于0，则使用select_field.in_(id_list)对查询对象进行过滤。
if id_list and len( id_list ) > 0:
query = query.filter( select_filed.in_( id_list ) )
# 调用query.all()执行查询，并将结果保存在列表list中。
list = query.all()
# 如果查询结果为空，则直接返回空字典ret。
if not list:
return ret
# 遍历查询结果列表list，对每个元素进行处理。
for item in list:
# 判断当前元素是否具有属性key_field，如果没有则跳出循环。
if not hasattr( item,key_field ):
break
# 将当前元素的key_field属性值作为键，将整个元素作为值，添加到字典ret中。
ret[ getattr( item,key_field ) ] = item
# 这段代码是使用Python中的getattr()函数和字典来实现动态赋值的操作。具体解释如下：
# getattr()函数是Python内置函数之一，用于获取对象的属性值。它接受两个参数，第一个参数是对象，第二个参数是属性名。
# 如果对象具有该属性，则返回属性值；如果对象没有该属性，则会引发AttributeError异常。
# 在这段代码中，item是一个对象，key_field是一个属性名。getattr( item,key_field )的作用是获取item对象的key_field属性的值。
#
# 然后，通过字典的方式将获取到的属性值赋给字典ret的相应键。这样就实现了动态赋值的操作。
return ret
# 这是一个名为selectFilterObj的函数，它接受两个参数obj和field。函数的作用是从给定的obj列表中筛选出具有指定属性field的对象，并返回一个去重后的列表。
def selectFilterObj( obj,field ):
# 创建一个空列表ret，用于存储筛选结果。
ret = []
# 遍历obj列表中的每个元素item。
for item in obj:
# 使用hasattr()函数检查item是否具有属性field，如果没有，则跳出循环。
if not hasattr(item, field ):
break
# 使用getattr()函数获取item的属性field的值，并判断该值是否已经存在于ret列表中，如果存在，则继续下一次循环。
if getattr( item,field ) in ret:
continue
# 将属性值添加到ret列表中。
ret.append( getattr( item,field ) )
# 循环结束后，返回去重后的列表ret。
return ret
mina/pages/my/order_list.wxml
<view class="container">
<view class="status-box">
<view bindtap="statusTap" class="status-label {{index == currentType ? 'active' : ''}}" wx:for-items="{{statusType}}" wx:key="{{index}}" data-index="{{index}}">
{{item}}
<view class="{{tabClass[index]}}"></view>
</view>
</view>
<view class="no-order" wx:if="{{!order_list.length}}">
<image src="/images/no-order.png" class="no-order-img"></image>
<view class="text">暂无订单</view>
</view>
<view class="order-list" wx:if="{{order_list.length}}">
<view class="a-order" wx:for="{{order_list}}" wx:key="{{index}}" wx:for-item="item">
<view class="order-date" data-id="{{item.order_sn}}" bindtap="orderDetail">
<view class="date-box">下单时间：{{item.date}}</view>
<view class="status {{(item.status==0 || item.status==1) ? '':'red'}}">{{item.status_desc}}</view>
</view>
<view class="goods-info" data-id="{{item.order_sn}}" bindtap="orderDetail">
<view class="goods-des">
<view>订单号:{{item.order_number}} </view>
<view wx:if="{{item.note && item.note != ''}}">备注： {{item.note}}</view>
</view>
</view>
<view >
<scroll-view class="goods-img-container" scroll-x="true">
<view class="img-box" wx:for="{{item.goods_list}}" wx:for-item="itemGood">
<image src="{{itemGood.pic_url}}" class="goods-img"></image>
</view>
</scroll-view>
</view>
<view class="price-box">
<view class="total-price">合计：¥ {{item.total_price}}</view>
<view class="btn cancel-btn" bindtap="orderCancel" data-id="{{item.order_sn}}" wx:if="{{item.status==-8}}">取消订单</view>
<view class="btn topay-btn" bindtap="toPay" data-id="{{item.order_sn}}" wx:if="{{item.status==-8}}">马上付款</view>
<view class="btn topay-btn" bindtap="orderConfirm" data-id="{{item.order_sn}}" wx:if="{{item.status==-6}}">确认收货</view>
<view class="btn topay-btn" bindtap="orderComment" data-id="{{item.order_sn}}" wx:if="{{item.status==-5}}">走，去评价</view>
</view>
</view>
</view>
</view>request.values
request.values是一个字典对象，用于获取HTTP请求中的参数。它可以获取GET和POST请求中的参数，并且可以处理表单数据、查询字符串和JSON数据。
request.values的使用方式如下：
- 获取GET请求中的参数：可以通过request.values.get(‘参数名’)来获取指定参数的值。
- 获取POST请求中的参数：可以通过request.values.get(‘参数名’)来获取指定参数的值。
- 获取表单数据：当请求的Content-Type为application/x-www-form-urlencoded或multipart/form-data时，可以通过request.values.get(‘参数名’)来获取表单字段的值。
- 获取查询字符串参数：可以通过request.values.get(‘参数名’)来获取查询字符串中的参数值。
- 获取JSON数据：当请求的Content-Type为application/json时，可以通过request.values.get(‘参数名’)来获取JSON数据中的参数值。
需要注意的是，request.values返回的是一个ImmutableMultiDict对象，它类似于字典，但是允许多个相同的键存在。如果需要获取所有相同键的值，可以使用request.values.getlist(‘参数名’)方法。
wxml中的动态类名的表达式
<view class="status-box">
<view bindtap="statusTap" class="status-label {{index == currentType ? 'active' : ''}}" wx:for-items="{{statusType}}" wx:key="{{index}}" data-index="{{index}}">
{{item}}
<view class="{{tabClass[index]}}"></view>
</view>
</view>列表渲染 | 微信开放文档 wx:for wx:for-index wx:for-item wx:key
wx:for-item 案例
wx:for-item 是微信小程序中的一个列表渲染的指令，用于遍历数组或对象，并将每个元素的值赋给指定的变量。下面是一个 wx:for-item 的案例：
<view wx:for="{{list}}" wx:for-item="item">
<text>{{item}}</text>
</view>在上述案例中，我们使用了 wx:for 指令来遍历名为 list 的数组，并将每个元素的值赋给名为 item 的变量。然后，我们在 <view> 标签内部使用了 item 变量来显示每个元素的值。
问题：wx:for-item 和wx:for-items 有什么区别
wx:for-item和wx:for-items是微信小程序中用于循环渲染列表的两个属性。
-
wx:for-item：用于指定每个循环项的临时变量名。
- 通过wx:for-item可以在循环中访问每个项的数据。
- 例如，可以使用
<view wx:for="{{list}}" wx:for-item="item">{{item}}</view>来遍历list数组，并在每个循环项中显示item的值。
-
wx:for-items：用于指定要循环渲染的数组或对象。
- wx:for-items接受一个数组或对象作为数据源。
- 例如，可以使用
<view wx:for-items="{{list}}">{{item}}</view>来遍历list数组，并在每个循环项中显示item的值。
区别：
- wx:for-item用于指定每个循环项的临时变量名，而wx:for-items用于指定要循环渲染的数据源。
- wx:for-item是在wx:for中使用的，用于访问每个循环项的数据；而wx:for-items是直接作为属性使用的，用于指定要循环渲染的数据源。
.in_()
在Python中，in是一个用于判断成员关系的运算符，用于检查一个值是否存在于一个容器（如列表、元组、字符串等）中。而.in_()是在表达式中使用in运算符的一种特殊形式。
.in_()方法通常用于SQLAlchemy等ORM（对象关系映射）库中，用于构建查询语句。它的作用是将in运算符应用于查询条件中的一个字段，以检查该字段的值是否在给定的列表或子查询结果中。
下面是.in_()方法的使用示例：
from sqlalchemy import create_engine, select, Table, Column, Integer, String
# 创建数据库引擎和表结构
engine = create_engine('sqlite:///example.db')
metadata = MetaData()
users = Table('users', metadata,
Column('id', Integer, primary_key=True),
Column('name', String),
Column('age', Integer))
# 构建查询语句
query = select([users]).where(users.c.age.in_([18, 20, 22]))
# 执行查询
with engine.connect() as conn:
result = conn.execute(query)
for row in result:
print(row)在上述示例中，.in_()方法被用于构建查询条件users.c.age.in_([18, 20, 22])，表示查询年龄字段在列表[18, 20, 22]中的记录。这样就可以筛选出年龄为18、20或22岁的用户信息。
<view class="btn topay-btn" bindtap="toPay" data-id="{{item.order_sn}}" wx:if="{{item.status==-8}}">马上付款</view>在这段代码中，data-id是一个自定义属性，它的值是{{item.order_sn}}。这里使用了小程序的数据绑定语法，{{item.order_sn}}表示将item对象中的order_sn属性的值赋给data-id。在实际运行时，data-id的值将根据item对象的order_sn属性动态变化。
问题: data-id是否是传给js文件中的data字典
在给定的代码中，data-id是一个自定义属性，它的值可以通过JavaScript文件中的data字典来获取。在JavaScript文件中，可以通过event.currentTarget.dataset.id来获取data-id的值。所以，data-id是传给JavaScript文件中的data字典的。
也就是说，在flask服务端的My.py文件中的"/my/order"路由里的筛选条件中的'id'就是此处wxml穿给js又传给py文件的。就是{{item.order_sn}}。
624
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
