小编Kev*_*ase的帖子

我目前正在编写一个需要频繁比较字符串长度的C程序,所以我编写了以下辅助函数:

int strlonger(char *s1, char *s2) {
    return strlen(s1) - strlen(s2) > 0;
}

我注意到,即使s1长度比短,函数返回true s2.有人可以解释这种奇怪的行为吗？

为什么你不能*args在Python中使用尾随逗号？换句话说,这是有效的

>>> f(1, 2, b=4,)

但事实并非如此

>>> f(*(1, 2), b=4,)
  File "<stdin>", line 1
    f(*(1, 2), b=4,)
                   ^
SyntaxError: invalid syntax

Python 2和Python 3都是这种情况.

当我使用下面的字符串作为正则表达式的输入时,Java挂起了100%的CPU使用率.

使用RegEx:

这是我的应用程序中描述字段使用的正则表达式.

^([A-Za-z0-9\\-\\_\\.\\&\\,]+[\\s]*)+

用于测试的字符串:

来自Provider_One的SaaS服务VLAN
第二次尝试使用Didier SPT,因为他给我的第一个是错的:-(

当我以不同的组合分割相同的字符串时,它可以正常工作.就像"来自Provider_One的SaaS服务VLAN","他给我的第一个是错误的:-("等等.Java仅挂起以上给定的字符串.

我也试过优化正则表达式如下.

^([\\w\\-\\.\\&\\,]+[\\s]*)+

即使这样也行不通.

以下Java代码ConcurrentModificationException按预期抛出:

public class Evil
{
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<String>();
        c.add("lalala");
        c.add("sososo");
        c.add("ahaaha");
        removeLalala(c);
        System.err.println(c);
    }
    private static void removeLalala(Collection<String> c) 
    {
        for (Iterator<String> i = c.iterator(); i.hasNext();) {
            String s = i.next();
            if(s.equals("lalala")) {
                c.remove(s);
            }
        }
    }
}

但是下面的示例(仅在内容中有所不同)Collection执行时没有任何异常:

public class Evil {
    public static void main(String[] args) 
    {
        Collection<String> c = new ArrayList<String>();
        c.add("lalala");
        c.add("lalala");
        removeLalala(c);
        System.err.println(c);
    }
    private static void removeLalala(Collection<String> c) {
        for (Iterator<String> i …

在对文件java.lang.Double.NaN说,这是

保持类型的非数字(NaN)值的常量double.它相当于返回的值Double.longBitsToDouble(0x7ff8000000000000L).

这似乎暗示还有其他人.如果是这样,我如何抓住它们,这可以移植吗？

需要明确的是,我想找到的double值x,使得

Double.doubleToRawLongBits(x) != Double.doubleToRawLongBits(Double.NaN)

和

Double.isNaN(x)

都是真的.

我正在编写一个函数库,可以安全地在各种数字类型之间进行转换或者尝试.我的意图大致相当于创建有用库和学习C边缘案例.

我int-到- size_t功能引发了GCC -Wtype-limits,声称我不应该测试,如果一个警告int是大于SIZE_MAX,因为它永远不会是真实的.(另一个转换int为ssize_t生成相同警告的函数SSIZE_MAX.)

我的MCVE,有额外的评论和婴儿步骤,是:

#include <stdint.h>  /* SIZE_MAX */
#include <stdlib.h>  /* exit EXIT_FAILURE size_t */

extern size_t i2st(int value) {
    if (value < 0) {
        exit(EXIT_FAILURE);
    }
    // Safe to cast --- not too small.
    unsigned int const u_value = (unsigned int) value;
    if (u_value > SIZE_MAX) {  /* Line 10 */
        exit(EXIT_FAILURE);
    }
    // Safe to cast --- not too big.
    return (size_t) …

我正在编写一个类,它有一些计算量很大的方法和一些用户希望迭代调整并且与计算无关的参数.

实际用途是用于可视化,但这是一个卡通示例:

class MyClass(object):

    def __init__(self, x, name, mem=None):

        self.x = x
        self.name = name
        if mem is not None:
            self.square = mem.cache(self.square)

    def square(self, x):
        """This is the 'computation heavy' method."""
        return x ** 2

    def report(self):
        """Use the results of the computation and a tweakable parameter."""
        print "Here you go, %s" % self.name
        return self.square(self.x)

基本思想是用户可能希望使用相同x但不同的name参数创建此类的许多实例.我想允许用户提供一个joblib.Memory将缓存计算部分的对象,这样他们就可以"报告"许多不同的名称,而无需每次重新计算平方数组.

(我知道这有点奇怪.用户需要为每个名称设置不同的类实例的原因是他们实际上正在与看起来像这样的接口函数进行交互.

def myfunc(x, name, mem=None):
    theclass = MyClass(x, name, mem)
    theclass.report()

但是现在让我们忽略它.

在joblib文档之后,我square …

Python 2.7中的这段代码创建了一个闭包func,包含par变量:

def creator(par):
    def func(arg):
        return par + arg
    return func

它可以像这样使用:

f = creator(7)
f(3)               # returns 10

在运行时,有没有办法获取定义闭包的函数的名称？那就是:只能访问f变量,我能获得f在creator函数内定义闭包的信息吗？

我使用的是Python 2.7.

我今天在python上进行Node练习。我似乎已经完成了其中的一部分，但这并不是完全的成功。

class Node:
    def __init__(self, cargo=None, next=None):
        self.cargo = cargo
        self.next  = next

    def __str__(self):
        return str(self.cargo)

node1 = Node(1)
node2 = Node(2)
node3 = Node(3)

node1.next = node2
node2.next = node3

def printList(node):
  while node:
    print node,
    node = node.next
  print

所以这是原始的__init__，__str__并且printList，这使得类似：1 2 3。

我必须转变1 2 3为[1,2,3]。

我append在创建的列表上使用过：

nodelist = []

node1.next = node2
node2.next = node3


def printList(node):
    while node:
        nodelist.append(str(node)), 
        node = node.next …

我有一个配置文件，其中定义了一些选项。有时，如果找不到请求的选项，我想忽略错误并返回None。

setting.cfg：

[Set]
ip=some_ip
verify=yes     #if verify does not exist here --> verify=None

test.py：

import sys
import ConfigParser

file="setting.cfg"

class ReadFile:
   def read_cfg_file(self):
      configParser = ConfigParser.RawConfigParser(allow_no_value=True)
      if os.path.isfile(file):
          configParser.read(file)
      else:
          sys.exit(1)
      try:
          verify = configParser.get('Set', 'verify')
      except ConfigParser.NoOptionError:
          pass

      return verify,and,lots,of,other,values

如果我这样处理它，我将无法返回值，因为如果'verify'找不到该选项，它就会简单地传递。

如果找不到选项，有什么方法可以忽略错误，而是返回None？

例如，这样的事情：

verify = configParser.get('Set', 'verify')
if not verify:
    verify=False