标签: nested

我继承了一个怪物.

它伪装成.NET 1.1应用程序处理符合医疗保健索赔支付(ANSI 835)标准的文本文件,但它是一个怪物.正在处理的信息涉及医疗保健索赔,EOB和报销.这些文件包含在前几个位置具有标识符的记录,以及根据该类型记录的规范格式化的数据字段.一些记录ID是控制段ID,它分隔与特定类型的事务相关的记录组.

为了处理文件,我的小怪物读取第一条记录,确定即将发生的交易类型,然后根据当前正在处理的交易类型开始处理其他记录.为此,它使用嵌套的if.由于存在多种记录类型,因此需要做出许多决定.每个决策都涉及一些处理和2-3个其他需要根据以前的决策做出的决定.这意味着嵌套if有很多巢.这就是我的问题所在.

这个嵌套if是715行长.恩,那就对了.七百五十条青少年线.我不是代码分析专家,因此我下载了几个免费软件分析工具,并得出了McCabe Cyclomatic Complexity评级为49.他们告诉我这是一个非常高的数字.在亚特兰大地区的花粉数量很高,其中100是高标准,新闻称"今天的花粉数量是1,523".这是我见过的箭头反模式最好的例子之一.在最高处,压痕深度为15个标签.

我的问题是,你建议采用什么方法来重构或重组这样的东西？

我花了一些时间寻找想法,但没有什么能给我一个良好的立足点.例如,用保护条件代替等级是一种方法.我只有其中一个.一窝下来,十四去.

也许有一种设计模式可能会有所帮助.指挥链会成为接近这个的方法吗？请记住,它必须保留在.NET 1.1中.

感谢您提出的所有想法.

我在实现一个嵌套类时遇到了麻烦,该类的构造函数是用一些封闭类的私有数据成员初始化的.

例:

Header File:
class Enclosing {
   //...Public members
   //...Private members
   int x, int y
   class Inner; // Declaration for nested class
};

Impl. File:
// Stuff...
class Enclosing::Inner {
    explicit Inner() : foo(x), bar(y) // foo and bar are data members of Inner
    //...
};

我收到一个invalid use of non-static data member错误.当涉及到其封闭类的成员的嵌套类访问时,是否有一些我缺少的东西？

我正在尝试解析表单的字符串:

'foo(bar:baz;x:y)'

我希望结果以嵌套字典的形式返回,即对于上面的字符串,结果应该如下所示:

{ 'foo' : { 'bar' : 'baz', 'x' : 'y' } }

尽管有许多Dict()和Group()的组合,但我无法让它发挥作用.我的(其中一个版本)语法看起来像这样:

import pyparsing as pp
field_name = pp.Word( pp.alphanums )
field_value = pp.Word( pp.alphanums )
colon = pp.Suppress( pp.Literal( ':' ) )

expr = pp.Dict( 
    pp.Group( 
        field_name + \
        pp.nestedExpr( 
            content = pp.delimitedList( 
                 pp.Group( field_name + colon + field_value ), 
                 delim = ';' 
            ) 
        ) 
    ) 
)

现在,结果如下:

In [62]: str = 'foo(bar:baz;x:y)'

In [63]: expr.parseString( str ).asList()
Out[63]: [['foo', [['bar', 'baz'], ['x', 'y']]]]

In …

我有一个这样的嵌套列表:

    my_list = [[1320120000000, 48596281], [1320206400000, 48596281], [1320292800000, 50447908]]

我想把它拆分成这样的东西:

    my_list1 = [48596281, 48596281, 50447908] 
    my_list2 = [1320120000000, 1320206400000, 1320292800000]    

我知道这很简单,但我无法让它发挥作用.任何帮助将非常感激.

我想要一个Python函数,它接受一个字符串,并返回一个数组,其中数组中的每个项目都是一个字符,或者是另一个这样的数组.嵌套数组在输入字符串中以'('和以')'开头标记.

因此,该函数将如下所示:

1) foo("abc") == ["a", "b", "c"]
2) foo("a(b)c") == ["a", ["b"], "c"]
3) foo("a(b(c))") == ["a", ["b", ["c"]]]
4) foo("a(b(c)") == error: closing bracket is missing
5) foo("a(b))c") == error: opening bracket is missing
6) foo("a)b(c") == error: opening bracket is missing

注意:我更喜欢纯粹功能性的解决方案.

对于大量嵌套字典,我想检查它们是否包含密钥.它们中的每一个都可能有也可能没有嵌套字典之一,所以如果我循环搜索所有这些字典会引发错误:

for Dict1 in DictionariesList:
     if "Dict4" in Dict1['Dict2']['Dict3']:
         print "Yes"

我目前的解决方案是:

for Dict1 in DictionariesList:    
    if "Dict2" in Dict1:
        if "Dict3" in Dict1['Dict2']:
            if "Dict4" in Dict1['Dict2']['Dict3']:
                print "Yes"

但这是令人头痛的,丑陋的,可能不是非常有效的资源.这是以第一种方式执行此操作的正确方法,但在字典不存在时不会引发错误？

我有下面的代码,目前只打印初始字典的值.但是,我想迭代嵌套字典的每个键,最初只打印名称.请参阅下面的代码:

Liverpool = {
    'Keepers':{'Loris Karius':1,'Simon Mignolet':2,'Alex Manninger':3},
    'Defenders':{'Nathaniel Clyne':3,'Dejan Lovren':4,'Joel Matip':5,'Alberto Moreno':6,'Ragnar Klavan':7,'Joe Gomez':8,'Mamadou Sakho':9}
}

for k,v in Liverpool.items():
    if k =='Defenders':
       print(v)

我有一个嵌套的 data.frames 列表，获取所有 data.frames 的列名的最简单方法是什么？

例子：

d = data.frame(a = 1:3, b = 1:3, c = 1:3)

l = list(a = d, list(b = d, c = d))

结果：

$a
[1] "a" "b" "c"

$b
[1] "a" "b" "c"

$c
[1] "a" "b" "c"

我希望采用任意数量的列表(例如[2,1,4 ...],[8,3,...],...)并从每个列表中选择数字以生成所有排列.例如:

[2,8,...],[2,3,...],[1,8,...],[1,3,...],[4,8,...], [4,3,...],......

这可以使用嵌套的for循环轻松完成,但由于我希望它接受任意数量的列表,似乎for循环必须是硬编码的.每个列表一个.此外,由于我的程序可能会产生数万个排列,我想一次生成一个单独的排列(而不是一次性计算它们并将结果存储到向量中).有没有办法以编程方式完成此操作？

由于在编译时知道列表的数量,我想也许我可以使用基于模板的元编程.然而,这看起来很笨拙,也不符合"一次一个"的要求.有什么建议？

链接包子句在Scala 2.8中引入,正如Martin Odersky在Scala 网站上所描述的那样.我不太了解这背后的直觉.

以下是Scala书中嵌套包的示例:

package bobsrockets {
    package navigation {
        // In package bobsrockets.navigation
        class Navigator
        package tests {
            // In package bobsrockets.navigation.tests
            class NavigatorSuite
        }
    }
}

嵌套包的这种使用情况是有道理的,因为我们可以在同一个文件中使用多个嵌套包,但是新的语法之前达到同样的事情,但没有支架.在简洁的Scala代码之间分离出包不难吗？

package bobsrockets
package navigation
// In package bobsrockets.navigation
class Navigator
package tests
// In package bobsrockets.navigation.tests
class NavigatorSuite

如果我弄错了,或者我误解了这个概念,请告诉我.