小编Vai*_*pai的帖子

我在提交日志中搜索了一个感兴趣的主题:

$ git log --pretty=oneline | grep -i ...

$SHA1 < ... commit message ... >

我现在有一个SHA1,我想知道有关影响该文件的信息,SHA1以及稍后可能diff与他们的父母有关的信息.我怎么能这样做？

潜入Python -

将它称为类的构造函数会很诱人但不正确.这很诱人,因为它看起来像构造函数(按照惯例, __init__是为类定义的第一个方法),就像一个(它是在新创建的类实例中执行的第一段代码),甚至听起来像一个( "init"肯定表明了构造函数的本质.不正确,因为调用时已经构造了对象__init__,并且您已经拥有对该类的新实例的有效引用.

报价表明,它是不正确调用__init__的构造函数,因为该对象已建成的时候__init__被调用.但!我一直的印象是,在构造函数只调用构造对象之后,因为它本质上是使用,如果该对象未通过时存在来初始化实例,它是没有意义的数据成员的构造函数被调用？(来自C++/Java背景)

我正在研究Java中的遗留API,Collection Framework并且我学到了诸如Vector并且HashTable已经被ArrayList和取代的类HashMap.

但是,它们仍然不被弃用,并且在本质上被视为遗留,弃用适用于被取代且应该避免的软件功能,因此,我不确定什么时候API被认为是遗留的以及何时被弃用.

在C++中,我必须明确指定'virtual'关键字以使成员函数'overridable',因为当成员函数被覆盖时,会产生创建虚拟表和vpointer的开销(因此每个成员函数都隐式不能覆盖表现原因).

当子类提供具有相同名称和签名的单独实现时,它还允许隐藏成员函数(如果未覆盖).

在C#中也使用相同的技术.我想知道为什么Java摆脱了这种行为,并默认使每个方法都可以覆盖,并提供了在显式使用'final'关键字时禁用覆盖行为的能力.

我尝试从父类的构造函数中调用重写方法,并注意到跨语言的不同行为.

C++- 回声A.foo()

class A{

public: 

    A(){foo();}

    virtual void foo(){cout<<"A.foo()";}
};

class B : public A{

public:

    B(){}

    void foo(){cout<<"B.foo()";}
};

int main(){

    B *b = new B(); 
}

Java- 回声B.foo()

class A{

    public A(){foo();}

    public void foo(){System.out.println("A.foo()");}
}

class B extends A{  

    public void foo(){System.out.println("B.foo()");}
}

class Demo{

    public static void main(String args[]){
        B b = new B();
    }
}

C#- 回声B.foo()

class A{

    public A(){foo();}

    public virtual void foo(){Console.WriteLine("A.foo()");}
}

class B …

我正在尝试使用需求文件安装python软件.

>> cat requirements.txt
Cython==0.15.1
numpy==1.6.1
distribute==0.6.24
logilab-astng==0.23.1logilab-common==0.57.1
netaddr==0.7.6
numexpr==2.0.1
ply==2.5
pycallgraph==0.5.1
pyflowtools==0.3.4.1
pylint==0.25.1
tables==2.3.1
wsgiref==0.1.2

所以我创建了一个虚拟环境

>> mkvirtualenv parser

(parser)
>> pip freeze
distribute==0.6.24
wsgiref==0.1.2

(parser)
>> pip install -r requirements.txt

...然后我下载了包但没有安装错误:http://pastie.org/4079800

(parser)
>> pip freeze
distribute==0.6.24
wsgiref==0.1.2

令人惊讶的是,如果我尝试手动安装每个包,他们安装就好了.例如:

>> pip install numpy==1.6.1

(parser)
>> pip freeze
distribute==0.6.24
wsgiref==0.1.2
numpy==1.6.1

我搞不清楚了.到底是怎么回事？

PS:我使用的pipv1.1和pythonV2.7.2与virtualenv和virtualenvwrapper

为什么我们有equals()和equalsIgnoreCase()作为两种不同的方法,什么时候equals()可以重载一个特殊的ignoreCase参数来提供equalsIgnoreCase()功能？

我很想知道使用自平衡树技术来存储项目的原因是什么,而不是使用哈希表.

我看到哈希表不能维护插入顺序,但我总是可以在顶部使用链表来存储插入顺序序列.

我看到,对于少量的值,哈希函数会增加成本,但我总是可以将哈希函数与密钥一起保存,以便更快地查找.

我知道散列表很难实现,而不是红黑树的直接实现,但在实际实现中,人们是否愿意为麻烦付出更多努力？

我看到使用哈希表发生冲突是正常的,但是使用双重哈希等开放寻址技术可以将密钥保存在哈希表本身中,并没有将问题减少到不倾向于使用优惠的效果对于这种实施,红黑树？

我很好奇,如果我严格地缺少哈希表的缺点,仍然使红黑树在实际应用(如文件系统等)中非常可行的数据结构.

谷歌Python类| 清单练习 -

给定一个数字列表,返回一个列表,其中所有相邻的==元素已减少为单个元素,因此[1,2,2,3]返回[1,2,3].您可以创建新列表或修改传入列表.

我使用新列表的解决方案是 -

def remove_adjacent(nums):
  a = []
  for item in nums:
    if len(a):
      if a[-1] != item:
        a.append(item)
    else: a.append(item)        
  return a

这个问题甚至暗示可以通过修改传入的列表来完成.但是,python文档警告不要在使用for循环迭代列表时修改元素.

我想知道除了迭代列表之外我还能尝试什么,以完成这项工作.我不是在寻找解决方案,但也许是一个可以带我走向正确方向的提示.

UPDATE

使用建议的改进更新了上述代码.

使用建议的提示使用while循环执行以下操作 -

def remove_adjacent(nums):
  i = 1
  while i < len(nums):    
    if nums[i] == nums[i-1]:
      nums.pop(i)
      i -= 1  
    i += 1
  return nums

我知道这[]表示一组允许的字符 -

>>> p = r'^[ab]$'
>>> 
>>> re.search(p, '')
>>> re.search(p, 'a')
<_sre.SRE_Match object at 0x1004823d8>
>>> re.search(p, 'b')
<_sre.SRE_Match object at 0x100482370>
>>> re.search(p, 'ab')
>>> re.search(p, 'ba')

但是......今天我在括号内看到了一个带有垂直条的表达式来定义相互排斥的模式 -

>>> q = r'^(a|b)$'
>>> 
>>> re.search(q, '')
>>> re.search(q, 'a')
<_sre.SRE_Match object at 0x100498dc8>
>>> re.search(q, 'b')
<_sre.SRE_Match object at 0x100498e40>
>>> re.search(q, 'ab')
>>> re.search(q, 'ba')

这似乎模仿了与上面相同的功能,或者我错过了什么？

PS:在Python括号中,它们用于定义匹配文本的逻辑组.如果我使用第二种技术,那么如何在两种工作中使用括号？