小编Cyk*_*ker的帖子

为什么Bar.go是OK有争论f2,但不与论证f1？

public class HelloWorld {
    public static void main(String[] args) {
        Foo<Foo<?>> f1 = new Foo<Foo<?>>();
        Foo<Foo<String>> f2 = new Foo<Foo<String>>();
        Bar.go(f1);     // not OK
        Bar.go(f2);     // OK
    }

    public static void p(Object o) {
        System.out.println(o);
    }
}

class Foo<E> {
}

class Bar {
    public static <T> void go(Foo<Foo<T>> f) {
    }
}

不应编译器自动推断类型T为capture of ?在这两种情况下？

我要Git回购repo1和repo2.有三个分支master,alpha并beta在repo1.repo2来自的克隆repo1.

在repo2,我可以看到远程跟踪分支git branch -a:

remotes/origin/HEAD -> origin/master
remotes/origin/master
remotes/origin/alpha
remotes/origin/beta

但该文件夹.git/refs/remotes/origin/中repo2只有一个文件HEAD,其内容是:

ref: refs/remotes/origin/master

所以这HEAD是一个象征性的参考.但为什么它指向一个不存在的引用？BTW,哪里repo2存储alpha和beta？的信息？(repo2知道alpha并且beta因为它显示了它们git branch -a.)

这个问题不是重复的

与一个进程进行多次通信而不破坏管道？

这个问题得到了解决，因为它的用例允许输入一起发送，但如果您的程序是交互式的（如此处的用例所示），则情况并非如此。

文件subprocess.Popen说：

communicate(input=None)
    Interact with process: Send data to stdin.  Read data from stdout
    and stderr, until end-of-file is reached.  Wait for process to
    terminate.  ...

是否可以在子进程终止之前与子进程进行多次通信，例如与终端或网络套接字？

例如，如果子进程是bc，则父进程可能希望根据需要向其发送不同的输入以进行计算。由于发送到的输入bc可能取决于用户输入，因此不可能一次发送所有输入。

是否可以配置setup.py以便递归地包含包数据？

例如,是否有相当于:

setup(...,
      packages=['mypkg'],
      package_data={'mypkg': ['data/*.dat']},
      )

它只是指定文件夹(可能有一些额外的选项)？

setup(...,
      packages=['mypkg'],
      package_data={'mypkg': ['data']},
      )

例子来自:

https://docs.python.org/2/distutils/setupscript.html#installing-package-data

为了演示此问题，请在 Linux 中运行以下命令后粘贴一个长字符串（>4096 字节）：

read foo && wc -c <<<"$foo"

结果是 4096，这意味着输入被截断。

一些研究表明，有一个终端行缓冲区大小硬编码为 4096，这解释了截断。然而，当我尝试使用该选项阅读时-n，它起作用了：

read -n 32768 foo && wc -c <<<"$foo"

结果是输入的实际长度（+1，但这是由于here-string）而不是4096。

所以我想知道这个选项有什么魔力-n 32768。我在 bash 手册页中没有找到关于此的相关信息。这是我们可以信赖的功能吗？

Python（3.8）代码：

#!/usr/bin/env python3

from decimal import Decimal
from decimal import getcontext

x = Decimal('0.6666666666666666666666666667')
y = x;
print(getcontext().prec)
print(y)
print(y == x)
y += x; y += x; y += x;
y -= x; y -= x; y -= x;
print(y)
print(y == x)

Python输出：

28
0.6666666666666666666666666667
True
0.6666666666666666666666666663
False

Java代码：

import java.math.BigDecimal;

public class A
{
    public static void main(String[] args)
    {
        BigDecimal x = new BigDecimal("0.6666666666666666666666666667");
        BigDecimal y = new BigDecimal("0.6666666666666666666666666667");

        System.out.println(x.precision());
        System.out.println(y.precision());

        System.out.println(y);
        System.out.println(y.equals(x));

        y = y.add(x); …

我希望git checkout <commit>将工作树和索引都刷新到<commit>版本.但是,在某些情况下,它将保留工作树和索引中的当前更改.例如:

git branch br1
git branch br2
git checkout br1
<make change M1 to file foo>
git add foo
<make change M2 to file foo>
git checkout br2

现在,所有的分支上的工作树/指数的变化br1保持在分支br2,作为git status上br2不会给人干净的消息.我想这是因为头部br1并且br2最初具有相同版本的文件foo,而Git可以自动检测到这一点.

题:

• Git什么时候决定不闪存工作树和索引？还有其他角落案件吗？

从这张图中，提交是指向根树的指针，根树是指向其他树和 blob 的指针。但什么是正确的指数观呢？

问题：

• 它是具有文件夹结构的类似树状结构还是只是斑点的平面视图？

• 如果索引是树状的，那么提交和索引之间有很大区别吗？

• 索引看起来更像是完整快照还是差异？

这是我的项目结构:

a
??? b.py
??? __init__.py

• 文件b.py为空.

• 文件__init__.py是一行:

  b = 'this is a str'
  

  Run Code Online (Sandbox Code Playgroud)

然后,以下程序给出了不一致的结果a.b:

import a
print(a.b)    # str
import a.b
print(a.b)    # module

检测变量和文件名之间这种名称冲突的最佳方法是什么？