文档建议反馈控制台
首页
学习
活动
专区
圈层
工具
文章/答案/技术大牛
发布
首页
学习
活动
专区
圈层
工具
返回腾讯云官网
社区首页 >问答首页 >找不到齐JSON解析器中缺少解析属性的原因

问找不到齐JSON解析器中缺少解析属性的原因
EN

Stack Overflow用户
提问于 2013-01-22 07:29:28
回答 2查看 600关注 0票数 2

问题：

  1. 在齐JSON解析器中找不到丢失解析属性的原因。解析器成功地解析了输入字符串，但是输出数据结构json_object只包含第一个属性(attribute_a)，而缺少其他属性(attribute_b和attribute_c)。

软件：使用Boost 1.52提升精神之气

Platform：Windows 7(64位)

编译器 (Visual 2010)

请求

  1. 帮助找出解析器没有找到所有属性的原因。
  2. 查看调试输出，我发现这些属性没有被放入单个std::vector中。我使用在http://www.json.org/上找到的JSON语法作为参考。作为“成员”的输出，我想看到的是一个包含为该JSON对象找到的所有json_pair对象的列表的std::vector。

限制

  1. 解析器不支持Unicode字符串。

代码：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
    #define BOOST_SPIRIT_DEBUG
    #include <boost/spirit/include/qi.hpp>
    #include <boost/spirit/include/phoenix_core.hpp>
    #include <boost/spirit/include/phoenix_container.hpp>
    #include <boost/spirit/include/phoenix_statement.hpp>
    #include <boost/spirit/include/phoenix_operator.hpp>
    #include <boost/fusion/include/adapt_struct.hpp>
    #include <boost/fusion/include/boost_tuple.hpp>
    #include <boost/variant/recursive_variant.hpp>

    #include <boost/make_shared.hpp>

    #include <vector>

    namespace signal_processing {
      namespace parsing {

        struct json_object;
        struct json_array;

        typedef boost::variant < std::string,
            double,
            boost::recursive_wrapper<json_object>,
            boost::recursive_wrapper<json_array>,
            bool > json_value;

        typedef boost::tuple < std::string, json_value> json_pair;

        struct json_members
        {
            std::vector < json_pair > items;
        };

        struct json_object
        {
            std::vector < json_members > children;
        };

        struct json_array
        {
            std::vector < json_value > list;
        };

        using boost::spirit::qi::bool_;
        using boost::spirit::qi::char_;
        using boost::spirit::qi::double_;
        using boost::spirit::qi::eol;
        using boost::spirit::qi::float_;
        using boost::spirit::qi::int_;
        using boost::spirit::qi::lexeme;
        using boost::spirit::qi::lit;   
        using boost::spirit::qi::space;
        using boost::spirit::qi::_val;
        using boost::spirit::qi::_1;

        template <typename Iterator, typename Skipper>
        struct json_grammar : boost::spirit::qi::grammar < Iterator, json_object(), Skipper>
        {
            json_grammar() : json_grammar::base_type(object)
            {
                object = '{' > *members > '}';

                pair = string > ':' > value;

                members = pair > *( ',' > members );

                element_list = '[' > *elements > ']';

                elements = value > *( ',' > elements );

                value = string |
                    number |
                    object |
                    element_list |
                    bool_ |
                    lit("null");

                char const* exclude = " ();\"\n\r\t";
                string = '"'
                    > +lexeme[char_ - char_(exclude)]
                    > '"';

                // Return: double
                number = double_ |
                    float_ |
                    int_;

                BOOST_SPIRIT_DEBUG_NODE(object);
                BOOST_SPIRIT_DEBUG_NODE(pair);
                BOOST_SPIRIT_DEBUG_NODE(members);
                BOOST_SPIRIT_DEBUG_NODE(element_list);
                BOOST_SPIRIT_DEBUG_NODE(elements);
                BOOST_SPIRIT_DEBUG_NODE(value);
                BOOST_SPIRIT_DEBUG_NODE(string);
                BOOST_SPIRIT_DEBUG_NODE(number);
            }

            boost::spirit::qi::rule < Iterator, json_object(), Skipper > object;
            boost::spirit::qi::rule < Iterator, json_pair(), Skipper > pair;
            boost::spirit::qi::rule < Iterator, json_members(), Skipper > members;
            boost::spirit::qi::rule < Iterator, json_array(), Skipper > element_list;
            boost::spirit::qi::rule < Iterator, json_array(), Skipper > elements;
            boost::spirit::qi::rule < Iterator, json_value(), Skipper > value;
            boost::spirit::qi::rule < Iterator, std::string(), Skipper > string;
            boost::spirit::qi::rule < Iterator, double(), Skipper > number;
        };
      }
    }

    BOOST_FUSION_ADAPT_STRUCT(
        signal_processing::parsing::json_object,
        (std::vector < signal_processing::parsing::json_members >, children)
    )

    BOOST_FUSION_ADAPT_STRUCT(
        signal_processing::parsing::json_members,
        (std::vector < signal_processing::parsing::json_pair >, items)
    )

    BOOST_FUSION_ADAPT_STRUCT(
        signal_processing::parsing::json_array,
        (std::vector < signal_processing::parsing::json_value >, list)
    )

    void parse ( std::string const& file )
    {
        typedef signal_processing::parsing::json_grammar < std::string::const_iterator, boost::spirit::ascii::space_type > configuration_grammar;
        configuration_grammar input; // Input grammar
        signal_processing::parsing::json_object parsed_data;

        std::string::const_iterator iter = file.begin();
        std::string::const_iterator end = file.end();
        bool r = boost::spirit::qi::phrase_parse ( iter, end, input, boost::spirit::ascii::space, parsed_data );

        if ( ! r || iter != end)
        {
            // Report the next 30 characters
            std::string::const_iterator some = iter + 30;

            if ( some > end )
            {
                some = end;
            }

            std::string context(iter, some);
            std::cout << "-------------------------\n";
            std::cout << "Parsing failed\n";
            std::cout << "stopped at: \": " << context << "...\"\n";
            std::cout << "-------------------------\n";
        }
    }

    int main(int,char**)
    {
        std::string input ( "{\r\n       \"Event\": {\r\n                \"attribute_a\": 0.0002,\r\n                \"attribute_b\": 2e-005,\r\n                \"attribute_c\": 0.022\r\n        }\r\n}" );

        parse ( input );

        return 0;
    }
boost
boost-spirit
boost-spirit-qi
c++
广告

云联络中心6.1折起

灵活稳定的一体化云联络中心，助力快速搭建集电话、在线交流、音视频通话为一体的客户联络平台
EN

回答 2

Stack Overflow用户

发布于 2013-01-22 09:40:48

解析器

一般来说，你的第一个问题的答案是，可能有几种方法可以实现你想要的。具体来说，我可以向你展示一种似乎可行的方法。

关键是正确设置与给定短语或令牌的一个或多个实例相匹配的规则的属性类型，方法是确保声明的实际上是容器，而不是具有容器成员的结构。

一旦您这样做了，您就需要编写规则，以便齐知道您正在处理的是一个容器，并且它应该在适当的情况下返回fill。

首先查看成员规则:您提供了以下规则：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
members = pair > *( ',' > members );

我不相信这本身就足以告诉齐，您希望它用pair来填充一个pair容器，特别是因为pairs和members不具有相同的属性类型。所以我建议你把这条规则改为：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
members = pair > *( ',' > pair );

甚至：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
members = pair % ',';

你需要确定这些规则是否是同一件事，但你明白了。

关于json_members类型:我更改了结构定义，使结构派生自容器，而不是将容器作为结构的属性：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
struct json_members : std::vector < json_pair > {};

你不需要做结构的融合化。

在我看来，下面是您代码的一个工作版本：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#define BOOST_SPIRIT_DEBUG
    #include <boost/spirit/include/qi.hpp>
    #include <boost/spirit/include/phoenix_core.hpp>
    #include <boost/spirit/include/phoenix_container.hpp>
    #include <boost/spirit/include/phoenix_statement.hpp>
    #include <boost/spirit/include/phoenix_operator.hpp>
    #include <boost/fusion/include/adapt_struct.hpp>
    #include <boost/fusion/include/boost_tuple.hpp>
    #include <boost/variant/recursive_variant.hpp>

    #include <boost/make_shared.hpp>

    #include <vector>

    namespace signal_processing {
      namespace parsing {

        struct json_object;
        struct json_array;

        typedef boost::variant < std::string,
            double,
            boost::recursive_wrapper<json_object>,
            boost::recursive_wrapper<json_array>,
            bool > json_value;

        typedef boost::tuple < std::string, json_value> json_pair;

//        struct json_members
//        {
//            std::vector < json_pair > items;
//        };
//
//        struct json_object
//        {
//            std::vector < json_members > children;
//        };
//
//        struct json_array
//        {
//            std::vector < json_value > list;
//        };

        struct json_members : std::vector < json_pair > {};
        struct json_object : std::vector < json_members > {};
        struct json_array : std::vector < json_value > {};

        using boost::spirit::qi::bool_;
        using boost::spirit::qi::char_;
        using boost::spirit::qi::double_;
        using boost::spirit::qi::eol;
        using boost::spirit::qi::float_;
        using boost::spirit::qi::int_;
        using boost::spirit::qi::lexeme;
        using boost::spirit::qi::lit;
        using boost::spirit::qi::space;
        using boost::spirit::qi::_val;
        using boost::spirit::qi::_1;

        template <typename Iterator, typename Skipper>
        struct json_grammar : boost::spirit::qi::grammar < Iterator, json_object(), Skipper>
        {
            json_grammar() : json_grammar::base_type(object)
            {
                object = '{' > *members > '}';

                pair = string > ':' > value;

                members = pair > *( ',' > pair );

                element_list = '[' > *elements > ']';

                elements = value > *( ',' > value );

                value = string |
                    number |
                    object |
                    element_list |
                    bool_ |
                    lit("null");

                char const* exclude = " ();\"\n\r\t";
                string = '"'
                    > +lexeme[char_ - char_(exclude)]
                    > '"';

                // Return: double
                number = double_ |
                    float_ |
                    int_;

                BOOST_SPIRIT_DEBUG_NODE(object);
                BOOST_SPIRIT_DEBUG_NODE(pair);
                BOOST_SPIRIT_DEBUG_NODE(members);
                BOOST_SPIRIT_DEBUG_NODE(element_list);
                BOOST_SPIRIT_DEBUG_NODE(elements);
                BOOST_SPIRIT_DEBUG_NODE(value);
                BOOST_SPIRIT_DEBUG_NODE(string);
                BOOST_SPIRIT_DEBUG_NODE(number);
            }

            boost::spirit::qi::rule < Iterator, json_object(), Skipper > object;
            boost::spirit::qi::rule < Iterator, json_pair(), Skipper > pair;
            boost::spirit::qi::rule < Iterator, json_members(), Skipper > members;
            boost::spirit::qi::rule < Iterator, json_array(), Skipper > element_list;
            boost::spirit::qi::rule < Iterator, json_array(), Skipper > elements;
            boost::spirit::qi::rule < Iterator, json_value(), Skipper > value;
            boost::spirit::qi::rule < Iterator, std::string(), Skipper > string;
            boost::spirit::qi::rule < Iterator, double(), Skipper > number;
        };
      }
    }

//    BOOST_FUSION_ADAPT_STRUCT(
//        signal_processing::parsing::json_object,
//        (std::vector < signal_processing::parsing::json_members >, children)
//    )
//
//    BOOST_FUSION_ADAPT_STRUCT(
//        signal_processing::parsing::json_members,
//        (std::vector < signal_processing::parsing::json_pair >, items)
//    )
//
//    BOOST_FUSION_ADAPT_STRUCT(
//        signal_processing::parsing::json_array,
//        (std::vector < signal_processing::parsing::json_value >, list)
//    )

    void parse ( std::string const& file )
    {
        typedef signal_processing::parsing::json_grammar < std::string::const_iterator, boost::spirit::ascii::space_type > configuration_grammar;
        configuration_grammar input; // Input grammar
        signal_processing::parsing::json_object parsed_data;

        std::string::const_iterator iter = file.begin();
        std::string::const_iterator end = file.end();
        bool r = boost::spirit::qi::phrase_parse ( iter, end, input, boost::spirit::ascii::space, parsed_data );

        if ( ! r || iter != end)
        {
            // Report the next 30 characters
            std::string::const_iterator some = iter + 30;

            if ( some > end )
            {
                some = end;
            }

            std::string context(iter, some);
            std::cout << "-------------------------\n";
            std::cout << "Parsing failed\n";
            std::cout << "stopped at: \": " << context << "...\"\n";
            std::cout << "-------------------------\n";
        }
    }

    int main(int,char**)
    {
        std::string input ( "{\r\n       \"Event\": {\r\n                \"attribute_a\": 0.0002,\r\n                \"attribute_b\": 2e-005,\r\n                \"attribute_c\": 0.022\r\n        }\r\n}" );

        parse ( input );

        return 0;
    }

其中产出：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
localhost stov # ./stov
<object>
  <try>{\r\n       "Event": {</try>
  <members>
    <try>\r\n       "Event": {\r</try>
    <pair>
      <try>\r\n       "Event": {\r</try>
      <string>
        <try>\r\n       "Event": {\r</try>
        <success>: {\r\n               </success>
        <attributes>[[E, v, e, n, t]]</attributes>
      </string>
      <value>
        <try> {\r\n                </try>
        <string>
          <try> {\r\n                </try>
          <fail/>
        </string>
        <number>
          <try> {\r\n                </try>
          <fail/>
        </number>
        <object>
          <try>{\r\n                "</try>
          <members>
            <try>\r\n                "a</try>
            <pair>
              <try>\r\n                "a</try>
              <string>
                <try>\r\n                "a</try>
                <success>: 0.0002,\r\n         </success>
                <attributes>[[a, t, t, r, i, b, u, t, e, _, a]]</attributes>
              </string>
              <value>
                <try> 0.0002,\r\n          </try>
                <string>
                  <try> 0.0002,\r\n          </try>
                  <fail/>
                </string>
                <number>
                  <try> 0.0002,\r\n          </try>
                  <success>,\r\n                "</success>
                  <attributes>[0.0002]</attributes>
                </number>
                <success>,\r\n                "</success>
                <attributes>[0.0002]</attributes>
              </value>
              <success>,\r\n                "</success>
              <attributes>[[[a, t, t, r, i, b, u, t, e, _, a], 0.0002]]</attributes>
            </pair>
            <pair>
              <try>\r\n                "a</try>
              <string>
                <try>\r\n                "a</try>
                <success>: 2e-005,\r\n         </success>
                <attributes>[[a, t, t, r, i, b, u, t, e, _, b]]</attributes>
              </string>
              <value>
                <try> 2e-005,\r\n          </try>
                <string>
                  <try> 2e-005,\r\n          </try>
                  <fail/>
                </string>
                <number>
                  <try> 2e-005,\r\n          </try>
                  <success>,\r\n                "</success>
                  <attributes>[2e-05]</attributes>
                </number>
                <success>,\r\n                "</success>
                <attributes>[2e-05]</attributes>
              </value>
              <success>,\r\n                "</success>
              <attributes>[[[a, t, t, r, i, b, u, t, e, _, b], 2e-05]]</attributes>
            </pair>
            <pair>
              <try>\r\n                "a</try>
              <string>
                <try>\r\n                "a</try>
                <success>: 0.022\r\n        }\r\n</success>
                <attributes>[[a, t, t, r, i, b, u, t, e, _, c]]</attributes>
              </string>
              <value>
                <try> 0.022\r\n        }\r\n}</try>
                <string>
                  <try> 0.022\r\n        }\r\n}</try>
                  <fail/>
                </string>
                <number>
                  <try> 0.022\r\n        }\r\n}</try>
                  <success>\r\n        }\r\n}</success>
                  <attributes>[0.022]</attributes>
                </number>
                <success>\r\n        }\r\n}</success>
                <attributes>[0.022]</attributes>
              </value>
              <success>\r\n        }\r\n}</success>
              <attributes>[[[a, t, t, r, i, b, u, t, e, _, c], 0.022]]</attributes>
            </pair>
            <success>\r\n        }\r\n}</success>
            <attributes>[[[[a, t, t, r, i, b, u, t, e, _, a], 0.0002], [[a, t, t, r, i, b, u, t, e, _, b], 2e-05], [[a, t, t, r, i, b, u, t, e, _, c], 0.022]]]</attributes>
          </members>
          <members>
            <try>\r\n        }\r\n}</try>
            <pair>
              <try>\r\n        }\r\n}</try>
              <string>
                <try>\r\n        }\r\n}</try>
                <fail/>
              </string>
              <fail/>
            </pair>
            <fail/>
          </members>
          <success>\r\n}</success>
          <attributes>[[[[[a, t, t, r, i, b, u, t, e, _, a], 0.0002], [[a, t, t, r, i, b, u, t, e, _, b], 2e-05], [[a, t, t, r, i, b, u, t, e, _, c], 0.022]]]]</attributes>
        </object>
        <success>\r\n}</success>
        <attributes>[[[[[a, t, t, r, i, b, u, t, e, _, a], 0.0002], [[a, t, t, r, i, b, u, t, e, _, b], 2e-05], [[a, t, t, r, i, b, u, t, e, _, c], 0.022]]]]</attributes>
      </value>
      <success>\r\n}</success>
      <attributes>[[[E, v, e, n, t], [[[[a, t, t, r, i, b, u, t, e, _, a], 0.0002], [[a, t, t, r, i, b, u, t, e, _, b], 2e-05], [[a, t, t, r, i, b, u, t, e, _, c], 0.022]]]]]</attributes>
    </pair>
    <success>\r\n}</success>
    <attributes>[[[[E, v, e, n, t], [[[[a, t, t, r, i, b, u, t, e, _, a], 0.0002], [[a, t, t, r, i, b, u, t, e, _, b], 2e-05], [[a, t, t, r, i, b, u, t, e, _, c], 0.022]]]]]]</attributes>
  </members>
  <members>
    <try>\r\n}</try>
    <pair>
      <try>\r\n}</try>
      <string>
        <try>\r\n}</try>
        <fail/>
      </string>
      <fail/>
    </pair>
    <fail/>
  </members>
  <success></success>
  <attributes>[[[[[E, v, e, n, t], [[[[a, t, t, r, i, b, u, t, e, _, a], 0.0002], [[a, t, t, r, i, b, u, t, e, _, b], 2e-05], [[a, t, t, r, i, b, u, t, e, _, c], 0.022]]]]]]]</attributes>
</object>

Unicode

我理解SVN构建的boost::spirit现在支持UTF8；尝试搜索BOOST_SPIRIT_UNICODE。您现在可以使用库中的宽字符串支持来支持'unicode‘(微软称之为unicode)。

免责声明

我正在做Linux的工作。YMMV

票数 1
EN

Stack Overflow用户

发布于 2013-04-25 18:43:13

我碰巧写了精神v2中的一种支持UNICODE的JSON解析器，下面是一个解析您的示例的试验案例：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
#include <sstream>
#include "JSON.hpp"

// util
static JSON::Value roundtrip(JSON::Value const& given) {
    return JSON::parse(to_wstring(given));
}

void roundtrip_test()
{
    auto 
        document = JSON::readFrom(std::istringstream(
                    "{\r\n"
                    "       \"Event\": {\r\n"
                    "             \"attribute_a\": 0.0002,\r\n"
                    "\"attribute_b\": 2e-005,\r\n"
                    "\"attribute_c\": 0.022\r\n"
                    "}\r\n}")),
        verify = roundtrip(document);

    std::cout << verify << "\n";
    std::cout << "document <=> verify equal:     \t" << std::boolalpha << (document == verify)                       << "\n";
    std::cout << "document <=> verify text match:\t" << std::boolalpha << (to_string(document) == to_string(verify)) << "\n";
}

这些指纹：

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
{"Event":{"attribute_a":0.0002,"attribute_b":2e-05,"attribute_c":0.022}}
document <=> verify equal:      true
document <=> verify text match: true

一些更多的API示例：

  1. 对象初始化表达式，用于“立即”JSON文档： void initializer_test() {使用命名空间JSON；const arr { L"text"，42，Object { L"dummy"，Null() } }；auto radius = as_double(arr1)；auto const document = Object { L"number“、314e-2 }、{ L"string”、L“hello\n别”}、{ L"array“、arr }、{ L"bool”、False() }、{ L" radius“、radius }、{ L"area”、radius ** 3.14 }，{字符串{ 10，L'=‘}，字符串{ 10，L’} }；std::cout << documentL"bool“<< std::endl；std::cout << documentL”<< std::endl；std:cout << documentL“字符串”<< std::endl；std:cout << documentL“数组”<< std::endl；std::cout << documentL bool“<< std::endl；std::cout << documentL"radius”<< std::endl；std::cout documentL"area“std:endl；cout <<文档<< std::endl；}
  2. 通过往返测试的这个样本输入： {“图像”：{“宽度”：800，“高度”：600，“标题”：“从15楼查看”，“缩略图”：{“俄文”：“Наберегупустынныхволн”，“Escape”："Ha \“0431\u0435\u0440\u0435\u0433\u0443\”显示\r\b\n“，"http://www.example.com/image/481989943"“："берегу"：”берегу“：125，”宽度“："100”}，“ID”：116,943,234,38793 }}
  3. 此访问者示例转换了一些JSON节点：如何操作JSON树的叶子
票数 0
EN
页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接：

https://stackoverflow.com/questions/14462098

复制
相关文章
【Python】列表 List ⑦ ( 列表遍历 | 使用 while 循环遍历列表 | 使用 for 循环遍历列表 | while 循环 与 for 循环对比 )
pythonlist遍历变量索引
将 列表 容器 中的数据元素 , 依次逐个取出进行处理的操作 , 称为 列表的遍历 ;
韩曙亮
2023/10/11
9160
列表,for循环相关.
for循环
#!/usr/bin/env python # -*- coding:utf-8 -*- # 1.简述解释型语言和编译型语言的区别？ """ 1.解释型语言:Python,PHP,Ruby. 特点是一行一行的解释,一行一行的传输给计算机,报错行前面可以执行. 2.编译型语言:C,C++,Java,C#,Go. 特点是一次性把语言编译成文件,报错则不能编译,编译好的文件一定可以运行. """ # 2.列举你了解的Python的数据类型？ """ 1.int:整型,数字 2.str:字符串 3.bool:布
py3study
2020/01/16
1.2K0
循环文件列表判断文件格式，并设置不同的图片作为图标
htmlgithubreturn
项目中遇到一个功能，详情页需要循环出上传的附件，但是附件的格式不是唯一，不同格式需要展示不同的图片做区分。
德顺
2020/01/14
9560
循环文件列表判断文件格式，并设置不同的图片作为图标
常用的DNS列表（亲测可用）
dnsjavahttps网络安全
如果经常遇到这样的问题：浏览器无法打开网站，但是qq、微信是正常使用的，说明DNS有问题。我们知道，默认情况下DNS是自动获取的，通常默认DNS就是路由器，然后由路由器负责向上一级路由查找，但是有时候路由器出现问题就可能造成上面的问题，那么如何一劳永逸的解决上面的问题呢？答案就是修改DNS，在手机、电脑上都可以更改，具体根据机型自行查找资料。
全栈程序员站长
2022/06/28
1.4K0
常用的DNS列表（亲测可用）
[Python基础08]列表和循环操作
编程算法
如果在某些情况下，我们要定义一个1~100的列表，是一件特别麻烦的事情，手工编码就会变得非常的繁琐，此时，我们可以使用第一种方式来进行列表的构建
周小董
2022/04/12
1.1K0
0428（字典，列表，循环）
存储key
该字典应包含键first_name 、last_name 、age 和city 。通过循环录入3个学生信息，存储到列表中， 并使用循环完成每个人具体信息的打印
py3study
2020/01/16
1.6K0
Python 的 map、列表推导、循环
python
发现map最快，map返回的是迭代器，如果变成list则花的时间与循环差不多，其次是列表推导，最后是循环来写。
py3study
2020/01/08
2.2K0
Python 的 map、列表推导、循环
INT：网络遥测不再遥不可测
kuberneteshttpsgit网络安全go
https://gitlab.tongyuejun.cn/p4git/Tofino-PINT
用户6874558
2023/02/15
5090
INT：网络遥测不再遥不可测
「学习笔记」循环、列表
breakcountfor循环reversesort
continue：终止本轮循环并开始下一轮循环（开始下一轮之前会先看循环条件是否满足，满足了才执行）
py3study
2020/01/21
7230
18. 再说循环~列表和循环的高级操作
存储python
在前面的课程中，我们已经学习了循环和函数的基本操作，这节内容主要针对循环和函数在项目使用过程中的一些更加有使用价值的操作进行分析和讲解
大牧莫邪
2018/08/27
1.2K0
全链路压测(12)：生产压测必不可少的环节
jvmblockmockps监控
全链路压测系列到这里，已经是第十二篇文章了，整个系列大概有14篇的样子，预计这个月会更新完毕。前面的文章，我用了很多的篇幅介绍了在事前调研和准备阶段要做的事情，为什么要花这么多篇幅介绍前期的准备工作呢？因为全链路压测严格来讲，并不是一个单纯的测试手段，而是一整套团队协作和稳定性保障的技术体系。
老_张
2022/05/17
1.9K0
全链路压测(12)：生产压测必不可少的环节
python二维列表排序
serverless
使用 lambda 关键词辅助对二维列表进行排序，lambda的使用方法参考https://blog.csdn.net/zjuxsl/article/details/79437563
py3study
2020/01/03
2.5K0
forEach循环实现卡片列表
jsp
jsp页面 <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> <!DOCTYPE html> <html lang="en"> <head> <% String path = request.getRequestURI(); Strin
王小婷
2019/05/06
4.3K0
forEach循环实现卡片列表
Python for循环生成列表
机器学习dataset
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
程裕强
2019/10/30
1.8K0
Python for循环生成列表
小程序循环列表删除当前选中列表的方法
小程序
需求：点击解绑按钮的时候，会删除当前所点击的列表. 点击试驾按钮的时候，左侧的图标会变成按钮一样的颜色。
王小婷
2019/01/28
2.4K0
小程序循环列表删除当前选中列表的方法
习题29：循环和列表
人工智能python
创建一个列表使用[]，在里面放入列表的数据，然后用逗号隔开，然后python接收这个列表以及里面所有的内容，将其赋给一个变量
py3study
2018/08/02
8310
PHP循环输出二维数组的数据
foreach协议
//下面是一个例子 $g_id = isset($_GET['id'])?$_GET['id']:'1';//定义变量$g_id,使用三元运算符是为了避免出现waring $p_id = ($g_id
Yiiven
2022/12/15
2.1K0
使用 Python 创建使用 for 循环的元组列表
python遍历管理函数数据
Python 的关键数据结构是列表和元组。元组元素一旦设置，就无法更改。这称为不可变性。但是列表元素可以在初始化后修改。在处理需要组合在一起的数据时，for 循环用于创建元组列表。列表比元组更具适应性，因为它们能够被修改。本教程演示如何使用 for 循环创建元组列表，从而简化重复性任务。
很酷的站长
2023/08/11
3950
使用 Python 创建使用 for 循环的元组列表
Python之初识二维列表
jquery编程算法pythonsql
二维列表是将其他列表当做列表的元素放在一个列表当中，也就是列表的嵌套。在Python中数组存在于第三方库中，因此在不安装第三方插件的前提下想要在Python中使用数组方法，就要采用二维列表这个方法。
楚客追梦
2022/11/11
1.5K0
Python 创建二维列表list
pythonlistmatrix
原因：matrix = [array] * 3操作中，只是创建3个指向array的引用，所以一旦array改变，matrix中3个list也会随之改变。
py3study
2020/01/03
2.8K0
Python 创建二维列表list

相似问题

不可测库存文件优先

10

海量不可测库存文件的目录结构

13

多个变量列表上的不可测循环

18

循环不可测循环列表

12

不可测库存链路

10
添加站长 进交流群

领取专属 10元无门槛券

AI混元助手 在线答疑

扫码加入开发者社群
关注 腾讯云开发者公众号

洞察 腾讯核心技术

剖析业界实践案例

扫码关注腾讯云开发者公众号
领券

腾讯云开发者

扫码关注腾讯云开发者

扫码关注腾讯云开发者

领取腾讯云代金券

热门产品

热门推荐

更多推荐

Copyright © 2013 - 2025 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档
查看详情【社区公告】 技术创作特训营有奖征文