小编pyr*_*ade的帖子

我在pyodbc中遇到段错误问题,想在Windows XP x86中调试它.但是,在线信息似乎主要以Linux为中心.最好的方法是什么？

鉴于下面的例子,哪个更pythonic？使用函数组合,lambdas或(现在用于)完全不同的东西？我不得不说lambdas似乎更具可读性,但Guido自己似乎想完全删除lambdas - http://www.artima.com/weblogs/viewpost.jsp?thread=98196

from functools import partial
from operator import not_, ge

def get_sql_data_type_from_string(s):
    s = str(s)

    # compose(*fs) -> returns composition of functions fs
    # iserror(f, x) -> returns True if Exception thrown from f(x), False otherwise

    # Using function composition
    predicates = (
        ('int',     compose(not_, partial(iserror, int))),
        ('float',   compose(not_, partial(iserror, float))),
        ('char',    compose(partial(ge, 1), len)))

    # Using lambdas
    predicates = (
        ('int',     lambda x: not iserror(int, x)),
        ('float',   lambda x: not iserror(float, x)),
        ('char',    lambda x: …

我似乎无法弄清楚为什么在将我的代码包装在ITVF中时,SQL Server采用完全不同的执行计划.在ITVF内部运行代码时,查询将在5秒内运行.如果我将其保存为ITVF,它将运行20分钟而不会产生结果.我更喜欢在ITVF中使用它来进行代码重用.将代码保存为ITVF的任何想法都会导致严重的性能问题？

CREATE FUNCTION myfunction
(
    @start_date date, 
    @stop_date date
)
RETURNS TABLE 
AS
RETURN 
(
    with
    ad as (
        select [START_DATE]
              ,[STOP_DATE]
              ,ID
              ,NAME
              ,'domain1\' + lower(DOMAIN1_NAME)
               collate database_default as ad_name
        from EMP_INFO
        where DOMAIN1_NAME != ''
        union
        select [START_DATE]
              ,[STOP_DATE]
              ,ID
              ,NAME
              ,'domain2\' + lower(DOMAIN2_NAME)
               collate database_default as ad_name
        from EMP_INFO
        where DOMAIN2_NAME != ''
    )
    select ad.ID
          ,ad.NAME
          ,COUNT(*) as MONITORS
    from scores
    join users
        on (scores.evaluator_id = users.[user_id])
    join ad
        on (lower(users.auth_login) = ad.ad_name and
            scores.[start_date] …

我试图在Data.Map.Map上实现Functor fmap,但是我收到了一个错误.我确信我不需要将Map转换为List以及从列表转换为了使其工作,但这是迄今为止我提出的最好的.

class Functor' f where
    fmap' :: (a -> b) -> f a -> f b

instance Functor' (Map.Map k) where
    fmap' f m
        | Map.null m = Map.empty
        | otherwise = let x:xs = Map.toList m
                          mtail = Map.fromList xs
                          a = fst x
                          b = snd x
                      in  Map.insert a (f b) (fmap f mtail)

错误:

No instance for (Ord k)
  arising from a use of `Map.fromList'
In the expression: Map.fromList xs
In an equation for `mtail': …

如何根据与之相关的模型过滤模型？下面的例子......这是有效的,但我认为这次击中了DB两次并且非常不优雅.有没有办法直接使用查询集？也许某种程度上select_related(),但一直没能想到那一个.我想返回QuerySet的Project.

from django.db import models

class Person(models.Model):
    pass

class Project(models.Model):
    pass

class Action(models.Model):
    person = models.ForeignKey(Person)
    project = models.ForeignKey(Project)

# Better way to do this?
def projects_by_person(person):
    actions = Action.objects.filter(person=person)
    project_ids = actions.values_list('project')
    return Project.objects.filter(id__in=project_ids)

我正在尝试使用Grammar-Kit插件为IntelliJ开发自定义语言插件.我很容易为定义的标记提供语法高亮,但我无法弄清楚如何在元素或标记 - 父级别突出显示.

这是一个快速而又脏的示例语言 - https://github.com/carymrobbins/intellij-plugin-example

解

正如@ignatov建议的那样,扩展Annotator类并在你的注册表中注册它plugin.xml.在下面的示例中,我们command通过定义visitCommand方法来突出显示元素.

public class SimpleAnnotator implements Annotator {
    @Override
    public void annotate(@NotNull final PsiElement element, @NotNull final AnnotationHolder holder) {
        element.accept(new SimpleVisitor() {
            @Override
            public void visitCommand(@NotNull SimpleCommand o) {
                super.visitCommand(o);
                setHighlighting(o, holder, SimpleSyntaxHighlighter.COMMAND);
            }
        });
    }

    private static void setHighlighting(@NotNull PsiElement element, @NotNull AnnotationHolder holder,
                                        @NotNull TextAttributesKey key) {
        holder.createInfoAnnotation(element, null).setEnforcedTextAttributes(TextAttributes.ERASE_MARKER);
        holder.createInfoAnnotation(element, null).setEnforcedTextAttributes(
                EditorColorsManager.getInstance().getGlobalScheme().getAttributes(key));
    }
}

我喜欢通过粘贴到解释器来解析Python中的特殊字符串.

>>> s = """Adams, John
... Washington,George
... Lincoln,Abraham
... Jefferson, Thomas
... """
>>> print "\n".join(x.split(",")[1].replace(" ", "")
                    for x in s.strip().split("\n"))
John
George
Abraham
Thomas

使用Python解释器可以很好地工作,但是我想用Haskell/GHCi来做这件事.问题是,我无法粘贴多行字符串.我可以使用带有EOF字符的getContents,但由于EOF字符关闭stdin,我只能执行一次.

Prelude> s <- getContents
Prelude> s
"Adams, John
Adams, John\nWashington,George
Washington,George\nLincoln,Abraham
Lincoln,Abraham\nJefferson, Thomas
Jefferson, Thomas\n^Z
"
Prelude> :{
Prelude| putStr $ unlines $ map ((filter (`notElem` ", "))
Prelude|                         . snd . (break (==','))) $ lines s
Prelude| :}
John
George
Abraham
Thomas
Prelude> x <- getContents
*** Exception: <stdin>: hGetContents: …

使用Haskell,如何使用文件中的现有私钥进行签名？

在Python中,它就像 -

import M2Crypto
rsa = M2Crypto.RSA.load_key("path/to/key")
result = rsa.sign("foo")

看来你可以用Codec.Crypto.RSA模块签名-

http://hackage.haskell.org/package/RSA-1.0.6.2/docs/Codec-Crypto-RSA.html#g:2

但我只看到如何从该模块生成新的私钥,而不是使用现有的私钥.似乎该Network.TLS.Extra模块提供从文件中读取私钥 -

http://hackage.haskell.org/package/tls-extra-0.6.1/docs/Network-TLS-Extra.html#g:6

不幸的是,从每个模块导出的PrivateKey类型彼此不兼容 -

Couldn't match expected type `crypto-pubkey-types-0.4.0:Crypto.Types.PubKey.RSA.PrivateKey'
            with actual type `tls-1.1.5:Network.TLS.Crypto.PrivateKey'

给定X和Y类,创建彼此类的实例最常用的方法是什么？例如 -

instance (X a) => Y a where ...
instance (Y a) => X a where ...

我想避免扩展.此外,我知道这可能会导致一些讨厌的无限递归,所以我愿意采用一种完全不同的方法来完成相同的事情并保持相对干燥.下面给出了我遇到的确切问题的一些背景 -

data Dealer = Dealer Hand
data Player = Player Hand Cash

class HasPoints a where
    getPoints :: a -> Int

class (HasPoints a) => CardPlayer a where
    getHand :: a -> Hand

    viewHand :: a -> TurnIsComplete -> Hand

    hasBlackjack :: a -> Bool
    hasBlackjack player = getPoints player == 21 &&
                          (length . getCards . getHand) player == 2 …