对于想了解Python-元组的读者，本文将是一篇不可错过的文章，我们将详细介绍a，b=，并且为您提供关于Bash–测试一个字符串是否比另一个字符串“更大”–它在内部如何工作？、for-each循环在J

对于想了解Python-元组的读者，本文将是一篇不可错过的文章，我们将详细介绍a，b=，并且为您提供关于Bash – 测试一个字符串是否比另一个字符串“更大” – 它在内部如何工作？、for-each循环在JAVA内部如何工作？、java-反射和远程处理在内部如何工作？、Java如何存储字符串以及子字符串在内部如何工作？[关闭]的有价值信息。

• Python-元组（a，b）=（b，a）中的成员交换在内部如何工作？（python中 元组）
• Bash – 测试一个字符串是否比另一个字符串“更大” – 它在内部如何工作？
• for-each循环在JAVA内部如何工作？
• java-反射和远程处理在内部如何工作？
• Java如何存储字符串以及子字符串在内部如何工作？[关闭]

Python-元组（a，b）=（b，a）中的成员交换在内部如何工作？（python中 元组）

In [55]: a = 5In [56]: b = 6In [57]: (a, b) = (b, a)In [58]: aOut[58]: 6In [59]: bOut[59]: 5

a和b的值交换在内部如何工作？它绝对不使用临时变量。

答案1

Python将右侧表达式与左侧赋值分开。首先评估右侧，并将结果存储在堆栈中，然后使用再次从堆栈中获取值的操作码分配左侧名称。

对于具有2或3个项目的元组分配，Python只是直接使用堆栈：

>>> import dis>>> def foo(a, b):...     a, b = b, a... >>> dis.dis(foo)  2           0 LOAD_FAST                1 (b)              3 LOAD_FAST                0 (a)              6 ROT_TWO                           7 STORE_FAST               0 (a)             10 STORE_FAST               1 (b)             13 LOAD_CONST               0 (None)             16 RETURN_VALUE        

在两个LOAD_FAST操作码（将一个变量中的值推入堆栈）之后，堆栈顶部保持[a, b]。该ROT_TWO操作码交换顶部的堆栈上的两个位置，使堆积现在有[b, a]在顶部。然后，这两个STORE_FAST操作码将使用这两个值并将它们存储在分配左侧的名称中。第一个STORE_FAST弹出堆栈顶部的值并将其放入堆栈a，下一个再次弹出，将值存储在中b。需要进行轮换，因为Python保证左侧目标列表中的分配是从左到右完成的。

对于3名分配，执行ROT_THREE后跟ROT_TWO以反转堆栈中的前三项。

对于更长的左侧分配，将建立一个显式元组：

>>> def bar(a, b, c, d):...     d, c, b, a = a, b, c, d... >>> dis.dis(bar)  2           0 LOAD_FAST                0 (a)              3 LOAD_FAST                1 (b)              6 LOAD_FAST                2 (c)              9 LOAD_FAST                3 (d)             12 BUILD_TUPLE              4             15 UNPACK_SEQUENCE          4             18 STORE_FAST               3 (d)             21 STORE_FAST               2 (c)             24 STORE_FAST               1 (b)             27 STORE_FAST               0 (a)             30 LOAD_CONST               0 (None)             33 RETURN_VALUE   

此处的堆栈[d, c, b, a]用于构建元组（以相反的顺序，BUILD_TUPLE再次从堆栈中弹出，将生成的元组推入堆栈中），然后UNPACK_SEQUENCE再次从堆栈中弹出元组，将所有元素从元组推回至再次堆叠以进行STORE_FAST操作。

后者似乎是一个浪费的操作，但是赋值的右侧可能完全不同，一个函数调用可能会生成一个元组，因此Python解释器不做任何假设，而是UNPACK_SEQUENCE始终使用操作码。即使对两个和三个名称的赋值操作也可以这样做，但是稍后的（窥孔）优化步骤使用上面的2或3个自变量替换了BUILD_TUPLE/ UNPACK_SEQUENCE组合，ROT_TWO并提高了ROT_THREE操作码的效率。

Bash – 测试一个字符串是否比另一个字符串“更大” – 它在内部如何工作？

[[ "f" > "a" ]]

STRING1 > STRING2
                 True if STRING1 sorts after STRING2 lexicographically.

else if ((op[0] == '>' || op[0] == '<') && op[1] == '\0')
  {
    if (shell_compatibility_level > 40 && flags & TEST_LOCALE)
      return ((op[0] == '>') ? (strcoll (arg1,arg2) > 0) : (strcoll (arg1,arg2) < 0));
    else
      return ((op[0] == '>') ? (strcmp (arg1,arg2) > 0) : (strcmp (arg1,arg2) < 0));
  }

for-each循环在JAVA内部如何工作？

我在进行函数调用时试图找到for-each循环的工作方式。请参阅以下代码，

public static int [] returnArr(){    int [] a=new int [] {1,2,3,4,5};    return a;}public static void main(String[] args){    //Version 1    for(int a : returnArr())    {        System.out.println(a);    }    //Version 2    int [] myArr=returnArr();    for(int a : myArr)    {        System.out.println(a);    }}

在版本1中，我在for-
each循环中调用returnArr（）方法，在版本2中，我显式调用returnArr（）方法并将其分配给数组，然后对其进行迭代。两种方案的结果都相同。我想知道哪个更有效以及为什么。

我认为版本2会更高效，因为我不会在每次迭代中都调用method。但是令我惊讶的是，当我使用版本1调试代码时，我发现方法调用只发生过一次！

谁能解释 一下它是如何工作的 ？当我为复杂对象编写代码时， 哪个更有效/更好 ？

答案1

我不会像以前的答案之一那样从Java语言规范中复制粘贴，而是以可读的格式解释该规范。

考虑以下代码：

for (T x : expr) {    // do something with x}

如果expr评估为您所用的数组类型，则语言规范指出所产生的字节码将与以下内容相同：

T[] arr = expr;for (int i = 0; i < arr.length; i++) {    T x = arr[i];    // do something with x}

所不同的只是，变量arr和i不幸地对您的代码或调试器不可见。这就是开发的原因，第二个版本可能更有用：将返回值存储在调试器可以访问的变量中。

在第一个版本expr中，函数调用是简单的，而在第二个版本中，您声明了另一个变量并将函数调用的结果分配给该变量，然后将该变量用作expr。我希望它们在性能上没有可测量的差异，因为第二个版本中的其他变量分配应该由JIT编译器优化，除非您在其他地方使用它。

java-反射和远程处理在内部如何工作？

Java如何存储字符串以及子字符串在内部如何工作？[关闭]

class StringTesting {
        public static void main(String args[])
        {
            String str = "abcd";
            String str1 = new String("abcd");
            String str2 = str.substring(0,2);
            String str3 = str.substring(0,2);
            String str4 = str.substring(0,str.length());
            String str5 = str1.substring(0,2);
            String str6 = str1.substring(0,2);
            String str7 = str1.substring(0,str1.length());

            System.out.println(str2 == str3);
            System.out.println(str == str4);
            System.out.println(str5 == str6);
            System.out.println(str1 == str7);
        }
    }

    false
    true
    false
    true

今天关于Python-元组和a，b=的分享就到这里，希望大家有所收获，若想了解更多关于Bash – 测试一个字符串是否比另一个字符串“更大” – 它在内部如何工作？、for-each循环在JAVA内部如何工作？、java-反射和远程处理在内部如何工作？、Java如何存储字符串以及子字符串在内部如何工作？[关闭]等相关知识，可以在本站进行查询。