在本文中，我们将为您详细介绍Python2.7获取用户输入并以不带引号的字符串形式进行操作的相关知识，并且为您解答关于python中用于获取用户输入的函数的疑问，此外，我们还会提供一些关于16.Pyt

在本文中，我们将为您详细介绍Python 2.7获取用户输入并以不带引号的字符串形式进行操作的相关知识，并且为您解答关于python中用于获取用户输入的函数的疑问，此外，我们还会提供一些关于16.Python input()函数：获取用户输入的字符串、Java - 手动解析不带引号的JSON字符串、Java 手动解析不带引号的JSON字符串的操作、java获取用户输入的字符串方法的有用信息。

本文目录一览：

• Python 2.7获取用户输入并以不带引号的字符串形式进行操作（python中用于获取用户输入的函数）
• 16.Python input()函数：获取用户输入的字符串
• Java - 手动解析不带引号的JSON字符串
• Java 手动解析不带引号的JSON字符串的操作
• java获取用户输入的字符串方法

Python 2.7获取用户输入并以不带引号的字符串形式进行操作（python中用于获取用户输入的函数）

我想从用户那里获取一个字符串，然后对其进行操作。

testVar = input("Ask user for something.")

没有我让用户在引号中键入其响应的方法，testVar是否可以成为字符串？即“你好”与你好

如果用户输入Hello，则会出现以下错误：

NameError：名称“ Hello”未定义

答案1

小编典典

使用raw_input()代替input()：

testVar = raw_input("Ask user for something.")

input()实际上将输入评估为Python代码。我建议不要使用它。 raw_input()返回用户输入的逐字字符串。

16.Python input()函数：获取用户输入的字符串

input() 函数用于向用户生成一条提示，然后获取用户输入的内容。由于 input() 函数总会将用户输入的内容放入字符串中，因此用户可以输入任何内容，input() 函数总是返回一个字符串。

例如如下程序：

第一次运行该程序，我们输入一个整数，运行过程如下：

请输入你的值：2
<class ''str''>
2

第二次运行该程序，我们输入一个浮点数，运行过程如下：

请输入你的值： 1.2
<class ''str''>
1.2

第三次运行该程序，我们输入一个字符串，运行过程如下：

请输入你的值：Hello
<class ''str''>
Hello

从上面的运行过程可以看出，无论输入哪种内容，始终可以看到 input() 函数返回字符串，程序总会将用户输入的内容转换成字符串。

需要指出的是，Python 2.x 提供了一个 raw_input() 函数，该 raw_input() 函数就相当于 Python 3.x 中的 input() 函数。

而 Python 2.x 也提供了一个 input() 函数，该 input() 函数则比较怪异：要求用户输入的必须是符合 Python 语法的表达式。通常来说，用户只能输入整数、浮点数、复数、字符串等。重点是格式必须正确，比如输入字符串时必须使用双引号，否则 Python 就会报错。

使用 Python 2.x 来运行上面程序，假如输入一个整数，运行过程如下：

请输入你的值：2
<class ''int''>
2

使用 Python 2.x 来运行上面程序，假如输入一个复数，运行过程如下：

请输入你的值： 2+3j
<type ''complex''>
(2+3j)

使用 Python 2.x 来运行上面程序，假如输入一个字符串，运行过程如下：

请输入你的值：Hello
NameError : name ''Hello'' is not defined

上面程序报错的原因是：Python 2.x 的 input() 函数要求用户输入字符串时必须用引号把字符串括起来。

在 Python 2.x 中应该尽量使用 raw_input() 函数来获取用户输入，因为 Python 2.x 中的 raw_input() 等同于 Python 3.x 中的 input()。

Java - 手动解析不带引号的JSON字符串

[TOC]

1 需求说明

项目中遇到了一批不带引号的类JSON格式的字符串:

{Name:Heal,Age:20,Tag:[Coding,Reading]}

需要将其解析成JSON对象, 然后插入到Elasticsearch中, 当作Object类型的对象存储起来.

在对比了阿里的FastJson、Google的Gson, 没找到想要的功能 ( 可能是博主不够仔细, 有了解的童学留言告诉我下呀), 于是就自己写了个工具类, 用来实现此需求.

如果是带有引号的标准JSON字符串, 可直接通过上述2种工具进行解析, 使用方法可参考: Java - 格式化输出JSON字符串的两种方式

2 解析代码

2.1 实现思路

代码的主要思路在注释中都有说明, 主要思路是:

(1) 借助Stack统计字符串首尾的[]、{}符号 —— []代表List, {}代表Map;

(2) 使用String#subString()方法缩减已解析的字符串;

(3) 使用递归解析内部的List、Map对象;

(4) 为了便于处理, 最小的key-value都解析成String类型.

需要注意的是: 要解析的字符串内部不要存在无意义的{、}、[、]符号, 否则会导致解析发生异常. —— 暂时没想到好的兼容方法, 有想法的童学请直接留言.**

2.2 详细代码

package com.healchow.util;

import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;

/**
 * Java 解析不带引号的JSON字符串
 *
 * @author Heal Chow
 * @date 2019/08/13 11:36
 */
public class ParseJsonStrUtils {

    public static void main(String[] args) {

        // 带引号的字符串, 会将字符串当作key-value的一部分, 因此这类字符串推荐使用fastJson、Gson等工具转换
        // 注意: String内部不要存在无意义的{、}、[、]符号 - 暂时没想到好的兼容方法
        /*String sourceStr = "{\"_index\":\"book_shop\"," +
                           "\"_id\":\"1\"," +
                           "\"_source\":{" +
                               "\"name\":\"Thinking in Java [4th Edition]\"," +
                               "\"author\":\"[US] Bruce Eckel\"," +
                               "\"price\":109.0,\"date\":\"2007-06-01 00:00:00\"," +
                               "\"tags\":[\"Java\",[\"Programming\"]" +
                           "}}";*/

        // 不带引号的字符串, 首尾多对[]、{}不影响解析
        String sourceStr = "[[[{" +
                            "{" +
                                "Type:1," +
                                "StoragePath:[{Name:/image/2019-08-01/15.jpeg,DeviceID:4401120000130},{ShotTime:2019-08-01 14:44:24}]," +
                                "Width:140" +
                            "}," +
                            "{" +
                                "Type:2,StoragePath:9090/pic/2019_08_01/src.jpeg," +
                                "Inner:{DeviceID:44011200}," +
                                "Test:[{ShotTime:2019-08-01 14:50:14}]," +
                                "Width:5600}" +
                            "}}]]]";

        List<Map<String, Object>> jsonArray;
        Map<String, Object> jsonMap;

        Object obj = null;
        try {
            obj = parseJson(sourceStr);
        } catch (Exception e) {
            System.out.println("出错啦: " + e.getMessage());
            e.printStackTrace();
        }

        if (obj instanceof List) {
            jsonArray = (List<Map<String, Object>>) obj;
            System.out.println("解析生成了List对象: " + jsonArray);
        } else if (obj instanceof Map) {
            jsonMap = (Map<String, Object>) obj;
            System.out.println("解析生成了Map对象: " + jsonMap);
        } else {
            System.out.println("需要解析的字符串既不是JSON Array, 也不符合JSON Object!\n原字符串: " + sourceStr);
        }
    }

    /**
     * 解析 Json 格式的字符串, 封装为 List 或 Map 并返回
     * 注意: (1) key 和 value 不能含有 ",", key 中不能含有 ":" —— 要分别用 "," 和 ":" 进行分隔
     *      (2) 要解析的字符串必须符合JSON对象的格式, 只对最外层的多层嵌套做了简单的处理,
     *          复杂的如"{a:b},{x:y}"将不能完全识别 —— 正确的应该是"[{a:b},{x:y}]"
     * @param sourceStr 首尾被"[]"或"{}"包围的字符串
     * @return 生成的JsonObject
     */
    public static Object parseJson(String sourceStr) throws InvalidParameterException {
        if (sourceStr == null || "".equals(sourceStr)) {
            return sourceStr;
        }

        // 判断字符串首尾有没有多余的、相匹配的 "[]" 和 "{}"
        String parsedStr = simplifyStr(sourceStr, "[", "]");
        parsedStr = simplifyStr(parsedStr, "{", "}");

        // 借助栈来实现 "[]" 和 "{}" 的出入
        Stack<String> leftSymbolStack = new Stack<>();
        Stack<String> rightSymbolStack = new Stack<>();

        if ((parsedStr.startsWith("[") && parsedStr.endsWith("]")) || (parsedStr.startsWith("{") && parsedStr.endsWith("}"))) {
            leftSymbolStack.push(parsedStr.substring(0, 1));
            rightSymbolStack.push(parsedStr.substring(parsedStr.length() - 1));
            parsedStr = parsedStr.substring(1, parsedStr.length() - 1);

            // parsedStr 内部还可能是连续的"{{}}"
            parsedStr = simplifyStr(parsedStr, "{", "}");
        } else {
            throw new InvalidParameterException("要解析的字符串中存在不匹配的''[]''或''{}'', 请检查!\n原字符串为: " + sourceStr);
        }

        // 保存解析的结果, jsonArray中可能只有String, 也可能含有Map<String, Object>
        List<Object> jsonArray = new ArrayList<>();
        Map<String, Object> jsonMap = new HashMap<>(16);

        // 内部遍历、解析
        innerParseByLoop(parsedStr, leftSymbolStack, rightSymbolStack, jsonArray, jsonMap);

        // 判断jsonArray是否为空
        if (jsonArray.size() > 0) {
            return jsonArray;
        } else {
            return jsonMap;
        }
    }

    /**
     * 循环解析内部的List、Map对象
     */
    private static void innerParseByLoop(String parsedStr, Stack<String> leftSymbolStack, Stack<String> rightSymbolStack,
                                         List<Object> jsonArray, Map<String, Object> jsonMap) throws InvalidParameterException {
        if (parsedStr == null || parsedStr.equals("")) {
            return;
        }
        // 按照","分隔
        String[] allKeyValues = parsedStr.split(",");
        if (allKeyValues.length > 0) {

            // 遍历, 并按照":"分隔解析
            out:
            for (String keyValue : allKeyValues) {

                // 如果keyValue中含有":", 说明该keyValue是List<Map>中的一个对象, 就需要确定第一个":"的位置 —— 可能存在多个":"
                int index = keyValue.indexOf(":");
                if (index > 0) {

                    // 判断key是否仍然以"{"或"["开始, 如果是, 则压栈
                    String key = keyValue.substring(0, index);
                    while (key.startsWith("[") || key.startsWith("{")) {
                        leftSymbolStack.push(key.substring(0, 1));
                        // 解析过的串要一直跟进
                        parsedStr = parsedStr.substring(1);
                        key = key.substring(1);
                    }

                    // 判读和value是否以"["开头 —— 又是一个 List 对象 —— 递归解析
                    String value = keyValue.substring(index + 1);
                    if (value.startsWith("[")) {
                        int innerIndex = parsedStr.indexOf("]");
                        List<Object> innerList = (List<Object>) parseJson(parsedStr.substring(key.length() + 1, innerIndex + 1));
                        jsonMap.put(key, innerList);
                        // 清除最后的"]", 并判断是否存在","
                        parsedStr = parsedStr.substring(innerIndex + 1);
                        if (parsedStr.indexOf(",") == 0) {
                            parsedStr = parsedStr.substring(1);
                        }

                        // 此内部存在对象, 内部的","已经解析完毕了, 要修正按照","切割的字符串数组, 并继续遍历
                        innerParseByLoop(parsedStr, leftSymbolStack, rightSymbolStack, jsonArray, jsonMap);
                        break;
                    }

                    // 判读和value是否以 "{" 开头 —— 又是一个 Map 对象 —— 递归解析
                    else if (value.startsWith("{")) {
                        int innerIndex = parsedStr.indexOf("}");
                        Map<String, Object> innerMap = (Map<String, Object>) parseJson(parsedStr.substring(key.length() + 1, innerIndex + 1));
                        jsonMap.put(key, innerMap);

                        // 清除最后的"}", 并判断是否存在","
                        parsedStr = parsedStr.substring(innerIndex + 1);
                        if (parsedStr.indexOf(",") == 0) {
                            parsedStr = parsedStr.substring(1);
                        }

                        // 此内部存在对象, 内部的","已经解析完毕了, 要修正按照","切割的字符串数组, 并继续遍历
                        innerParseByLoop(parsedStr, leftSymbolStack, rightSymbolStack, jsonArray, jsonMap);
                        break;
                    }

                    // 最后判断value尾部是否含有 "]" 或 "}"
                    else {
                        while (value.endsWith("]") || value.endsWith("}")) {
                            // 最右侧的字符
                            String right = value.substring(value.length() - 1);
                            // 此时栈顶元素
                            String top = leftSymbolStack.peek();
                            // 如果有相匹配的, 则弹栈, 否则忽略
                            if (("}".equals(right) && "{".equals(top)) || ("]".equals(right) && "[".equals(top))) {
                                leftSymbolStack.pop();
                                value = value.substring(0, value.length() - 1);
                                jsonMap.put(key, value);

                                // 清除最后的"}", 并判断是否存在","
                                parsedStr = parsedStr.substring(key.length() + 1 + value.length() + 1);
                                if (parsedStr.indexOf(",") == 0) {
                                    parsedStr = parsedStr.substring(1);
                                }

                                // 解析完成了一个对象, 则将该元素添加到List中, 并创建新的对象
                                jsonArray.add(jsonMap);
                                jsonMap = new HashMap<>(16);

                                // 继续进行外层的解析
                                continue out;
                            }

                            // 如果都不匹配, 则有可能是源字符串的最后一个符号
                            else {
                                rightSymbolStack.push(right);
                                value = value.substring(0, value.length() - 1);
                            }
                        }
                        jsonMap.put(key, value);
                        int length = key.length() + value.length() + 2;
                        if (parsedStr.length() > length) {
                            parsedStr = parsedStr.substring(length);
                        } else {
                            parsedStr = "";
                        }
                    }
                }
                // 如果keyValue中不含":", 说明该keyValue只是List<String>中的一个串, 而非List<Map>中的一个Map, 则直接将其添加到List中即可
                else {
                    jsonArray.add(keyValue);
                }
            }

            // 遍历结束, 处理最后的符号问题 —— 判断左右栈是否匹配
            while (!leftSymbolStack.empty()) {
                if (leftSymbolStack.peek().equals("{") && parsedStr.equals("}")) {
                    leftSymbolStack.pop();
                }
                if (!rightSymbolStack.empty()) {
                    if (leftSymbolStack.peek().equals("{") && rightSymbolStack.peek().equals("}")) {
                        leftSymbolStack.pop();
                        rightSymbolStack.pop();
                    } else if (leftSymbolStack.peek().equals("[") && rightSymbolStack.peek().equals("]")) {
                        leftSymbolStack.pop();
                        rightSymbolStack.pop();
                    } else {
                        throw new InvalidParameterException("传入的字符串中不能被解析成JSON对象!\n原字符串为: " + parsedStr);
                    }
                }
            }
        }
    }

    /**
     * 判断字符串首尾有没有多余的、相匹配的 "[]" 和 "{}", 对其进行简化
     */
    private static String simplifyStr(String sourceStr, String firstSymbol, String lastSymbol) {

        while (sourceStr.startsWith(firstSymbol) && sourceStr.endsWith(lastSymbol)) {
            String second = sourceStr.substring(1, 2);
            // 如果第二个仍然是"["或"{", 再判断倒数第二个是不是"]"或"}" —— 说明长度至少为3, 不会发生 IndexOutOfBoundsException
            if (second.equals(firstSymbol)) {
                String penultimate = sourceStr.substring(sourceStr.length() - 2, sourceStr.length() - 1);
                if (penultimate.equals(lastSymbol)) {
                    // 缩短要解析的串
                    sourceStr = sourceStr.substring(1, sourceStr.length() - 1);
                } else {
                    break;
                }
            } else {
                break;
            }
        }
        return sourceStr;
    }

}

2.3 测试样例

(1) 带引号的测试:

// 测试字符串:
String sourceStr = "{\"_index\":\"book_shop\"," +
                   "\"_id\":\"1\"," +
                   "\"_source\":{" +
                       "\"name\":\"Thinking in Java [4th Edition]\"," +
                       "\"author\":\"[US] Bruce Eckel\"," +
                       "\"price\":109.0,\"date\":\"2007-06-01 00:00:00\"," +
                       "\"tags\":[\"Java\",[\"Programming\"]" +
                   "}}";

解析结果为: <img src="https://img2018.cnblogs.com/blog/1438655/201908/1438655-20190820124256767-682854686.jpg" width="65%" alt="字符串解析结果-带引号" />

(2) 不带引号的测试:

// 测试字符串: 
String sourceStr = "[[[{" +
                    "{" +
                        "Type:1," +
                        "StoragePath:[{Name:/image/2019-08-01/15.jpeg,DeviceID:4401120000130},{ShotTime:2019-08-01 14:44:24}]," +
                        "Width:140" +
                    "}," +
                    "{" +
                        "Type:2,StoragePath:9090/pic/2019_08_01/src.jpeg," +
                        "Inner:{DeviceID:44011200}," +
                        "Test:[{ShotTime:2019-08-01 14:50:14}]," +
                        "Width:5600}" +
                    "}}]]]";

解析结果为:

<img src="https://img2018.cnblogs.com/blog/1438655/201908/1438655-20190820124345323-1941086699.jpg" width="65%" alt="字符串解析结果-不带引号" />

<br/>

版权声明

出处: 博客园 瘦风的博客(https://www.cnblogs.com/shoufeng)

感谢阅读, 如果文章有帮助或启发到你, 点个[<a href="javascript:void(0);" onclick="DiggIt(11382231,cb_blogId,1);green_channel_success(this,''谢谢推荐'');">好文要顶</a>] 或 [<a href="javascript:void(0);" onclick="votePost(11382231,''Digg'')">推荐</a>] 吧

本文版权归博主所有, 欢迎转载, 但 [必须在文章页面明显位置标明原文链接], 否则博主保留追究相关人员法律责任的权利.

原文出处：https://www.cnblogs.com/shoufeng/p/11382231.html

Java 手动解析不带引号的JSON字符串的操作

这篇文章主要介绍了Java 手动解析不带引号的JSON字符串的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧

1 需求说明

项目中遇到了一批不带引号的类JSON格式的字符串:

{Name:Heal,Age:20,Tag:[Coding,Reading]}

需要将其解析成JSON对象, 然后插入到Elasticsearch中, 当作Object类型的对象存储起来.

在对比了阿里的FastJson、Google的Gson, 没找到想要的功能 ( 可能是博主不够仔细, 有了解的童学留言告诉我下呀上一篇：详解在springboot中使用Mybatis Generator的两种方式下一篇：Java IO流 File类的常用API实例

热门搜索：

操作字符串 

字符串操作 

Json字符串 

Java字符串 

字符串操作类 

相关文章

Java 手动解析不带引号的JSON字符串的操作

2021-11-15阅读(2443)评论(0)推荐()

这篇文章主要介绍了Java 手动解析不带引号的JSON字符串的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧

C#解析json字符串总是多出双引号的原因分析及解决办法

2021-10-06阅读(9712)评论(0)推荐()

json好久没用了，今天在用到json的时候，发现对字符串做解析的时候总是多出双引号，下面给大家介绍C#解析json字符串总是多出双引号的原因分析及解决办法，需...

解析错误富文本json字符串(带双引号)的快速解决方法

2021-10-05阅读(9078)评论(0)推荐()

下面小编就为大家带来一篇解析错误富文本json字符串(带双引号)的快速解决方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧

Java Json字符串的双引号("")括号如何去掉

2021-09-19阅读(3408)评论(0)推荐()

这篇文章主要介绍了Java Json字符串的双引号("")括号如何去掉？具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧

Java字符串操作和C#字符串操作的不同小结

2021-11-08阅读(10707)评论(0)推荐()

在JAVA语言中,字符串数据实际上由String类所实现的。下面这篇文章主要给大家介绍了关于Java字符串操作和C#字符串操作的不同的相关资料，文中通过示例代码...

Shell脚本字符串单引号和双引号的区别浅析

2021-09-13阅读(9242)评论(0)推荐()

这篇文章主要介绍了Shell脚本字符串单引号和双引号的区别浅析,,并罗列了一些字符串的操作方法,需要的朋友可以参考下

java中字符串参数化符号${}的解析

2021-10-12阅读(8025)评论(0)推荐()

这篇文章主要给大家介绍了java中字符串参数化符号${}是如何解析的,文中给出了详细的分析与解决代码，有需要的朋友可以参考借鉴，下面来一起看看吧。

取消

有人回复时邮件通知我

提交评论

java获取用户输入的字符串方法

今天小编就为大家分享一篇java获取用户输入的字符串方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧

问题描述

很多同学跟我一样，都是刚开始接触java，可能从c语言突然转为java语言，有些跟我一样手足无措，那怎么获取用户输入的字符串！

如下示列：

import Java.util.Scanner; //导入输入类   public static void main(String[] args) {      //创建输入对象   Scanner sc=new Scanner(system.in);      //获取用户输入的字符串   String str=null;   System.out.print("请输入任意字符:");   str=sc.nextLine();      System.out.println("你输入的字符为:"+str);     }

以上这篇java获取用户输入的字符串方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持小编。

今天关于Python 2.7获取用户输入并以不带引号的字符串形式进行操作和python中用于获取用户输入的函数的介绍到此结束，谢谢您的阅读，有关16.Python input()函数：获取用户输入的字符串、Java - 手动解析不带引号的JSON字符串、Java 手动解析不带引号的JSON字符串的操作、java获取用户输入的字符串方法等更多相关知识的信息可以在本站进行查询。

本文标签：

• Python 2.7
• 用户输入
• 不带引号的字符串
• 获取函数