小编Jos*_*h.F的帖子

我在新建的计算机上安装了新安装的Ubuntu.我刚刚使用apt-get安装了python-pip.现在,当我尝试pip安装Numpy和Pandas时,它会出现以下错误.

我已经在SO和谷歌的很多地方看到过这个错误,但我找不到解决方案.有人提到它是一个bug,有些线程刚刚死了......发生了什么事？

Traceback (most recent call last):
  File "/usr/bin/pip", line 9, in <module>
    load_entry_point('pip==1.5.4', 'console_scripts', 'pip')()
  File "/usr/lib/python2.7/dist-packages/pip/__init__.py", line 185, in main
    return command.main(cmd_args)
  File "/usr/lib/python2.7/dist-packages/pip/basecommand.py", line 161, in main
    text = '\n'.join(complete_log)
UnicodeDecodeError: 'ascii' codec can't decode byte 0xe2 in position 72: ordinal not in range(128)

我一直在玩Cofree,并且不能完全理解它.

例如,我想Cofree [] Num在ghci中玩,并且不能得到任何有趣的例子.

例如,如果我构造一个Cofree类型:

let a = 1 :< [2, 3]

我希望extract a == 1,但我得到这个错误:

No instance for (Num (Cofree [] a0)) arising from a use of ‘it’
    In the first argument of ‘print’, namely ‘it’
    In a stmt of an interactive GHCi command: print it

还有一种:

extract a :: (Num a, Num (Cofree [] a)) => a

我可以得到一些简单的例子,甚至是琐碎的,如何使用Cofree有,比方说,函子:[],或者Maybe,或者Either,演示

• extract
• extend
• unwrap
• duplicate？

Cross发布:https: …

我正在阅读Bartosz的精彩博客,并继续挑战问题3,我有点难过:

https://bartoszmilewski.com/2015/04/07/natural-transformations/

Q3:从定义一些自然变换Reader Bool到Maybe

我已将Reader函子定义为:

newtype Reader e a = Reader (e->a)

runReader :: Reader e a -> e -> a
runReader (Reader f) env = f env

instance Functor (Reader e) where
    fmap f (Reader g) = Reader (\x -> f (g x))

我想找到一个自然的转变

n :: Reader Bool a -> Maybe a

我的直觉是,如果Reader环境是True,我可以拥有Just a,如果False,然后自然转型项目Nothing.但是感觉有点像monadic,或者像Maybe嵌套在里面Reader一样Reader Bool (Maybe Int),所以我不确定.

我不能断定如何做到这一点.我最好的是:

n :: …

在使用条件时,使用Python返回内容的正确方法是以下哪一种？有关系吗？为什么？

# OPTION 1
if conditional:
    return a
else:
    return b


# OPTION 2
if conditional:
    return a
return b

API应该允许包含用户想要抓取的URL的任意HTTP get请求,然后Flask应该返回scrape的结果.

以下代码适用于第一个http请求,但在反应器停止后,它将不会重新启动.我甚至可能不会以正确的方式解决这个问题,但我只是想在Heroku上放置一个RESTful scrapy API,到目前为止,我所能想到的就是它.

有没有更好的方法来构建这个解决方案？或者如何scrape_it在不停止扭曲的反应堆(不能再次启动)的情况下允许返回？

from flask import Flask
import os
import sys
import json

from n_grams.spiders.n_gram_spider import NGramsSpider

# scrapy api
from twisted.internet import reactor
import scrapy
from scrapy.crawler import CrawlerRunner
from scrapy.xlib.pydispatch import dispatcher
from scrapy import signals

app = Flask(__name__)


def scrape_it(url):
    items = []
    def add_item(item):
        items.append(item)

    runner = CrawlerRunner()

    d = runner.crawl(NGramsSpider, [url])
    d.addBoth(lambda _: reactor.stop()) # <<< TROUBLES HERE ???

    dispatcher.connect(add_item, signal=signals.item_passed)

    reactor.run(installSignalHandlers=0) # the script will block here until the …

我仍然试图掌握回调(来自类别理论),限制和通用属性的直觉,而我并没有完全发现它们的用处,所以也许你可以帮助对此有所了解以及验证我的琐碎例子？

以下是故意冗长的,回调应该是(p, p1, p2),并且(q, q1, q2)是非通用对象的一个​​示例,以"测试"回调以查看事情是否正常通信.

-- MY DIAGRAM, A -> B <- C
type A = Int
type C = Bool
type B = (A, C)
f :: A -> B
f x = (x, True)
g :: C -> B
g x = (1, x)

-- PULLBACK, (p, p1, p2)
type PL = Int
type PR = Bool
type P = (PL, PR)
p = (1, True) :: P
p1 = fst …

我有几个选择,但两者看起来都有点滞后,我认为应该有更好的选择.我只是希望能够创建表单,甚至动态创建表单(例如,从我的应用程序中向表单添加行),并具有试剂/重新框架/反应适当的访问不同输入的值.

不确定这些中的任何一个是否是最佳替代方案,因为它们都在每次运行之后运行:on-change...

选项#1 - 更新:on-change到全局原子

[:input {:value       @new-job-form
         :on-change   #(dispatch [:new-job-form (-> % .-target .-value)])}]

(reg-event-db
 :new-job-form
 (fn [db [_ v]]
   (assoc db :new-job-form v)))

选项#2 - 更新一些只调度到全局原子的本地状态:on-blur

(defn text-input
  "adapted from:
  https://yogthos.net/posts/2016-09-25-ReagentComponents.html

  The big idea is this holds local state, and pushes it to the global
  state only when necessary"
  [{:keys [sub-path disp]}]
  (r/with-let [value    (r/atom nil)
               focused? (r/atom false)]
    [:div
     [:input
      {:type      :text
       :on-focus  #(do (reset! value @(subscribe sub-path))
                       (reset! focused? true))
       :on-blur …

编辑:对于有类似疾病的人,我发现这与"可扩展记录问题"有关,我将亲自研究这些问题.

编辑2:我已经开始通过非常明确地了解数据类型以及每个语义数据单元具有多种数据类型来解决这个问题(几周后).例如,如果数据库包含一个X,我的代码有一个XAction用于表示我想用a做的事情X,以及XResponse用于将Xs 中继到http客户端的代码.然后我需要构建支持代码来在实例之间穿梭.不理想,但是,我喜欢它是明确的,并且希望当我的模型结晶时,它不应该真的需要太多保持,并且应该非常可靠.

我不确定解决这个问题的正确抽象级别是什么(即记录？还是Yesod？)所以我将只列出一个简单的案例.

简单案例/ TL; DR

我想将请求主体解码为一个类型

data Comment = Comment {userid :: ..., comment :: ...}

但实际上我不希望请求体包含userid,服务器将根据其Auth Headers(或者我想要将数据默认填充字段的任何地方)提供.

所以他们实际上传给我的是:

data SimpleComment = SimpleComment {comment :: ...} deriving (Generic, FromJSON)

我把它变成了一个Comment.但同时保持两种几乎相同的类型是麻烦,而不是干.

我该如何解决这个问题？

问题详情

我有一个记录类型:

data Comment = Comment {userid :: ..., comment :: ...}

我有一个POST路线:

postCommentR :: Handler Value
postCommentR = do
  c <- requireJsonBody :: (Handler Comment)
  insertedComment <- runDB ...
  returnJson insertedComment

请注意,Route要求用户提供 …

在下面的代码中，我有两个队列来运行不同类型的线程。这些线程递归地添加到彼此的队列中（队列 1 获取一些信息，队列 2 处理它并将更多信息添加到队列 1）。

我想等到两个队列中的所有项目都被完全处理。目前我正在使用此代码

queue.join()
out_queue.join()

问题是当第一个队列暂时用完要做的事情时，它会关闭，因此在此之后它永远不会看到队列 2（out_queue）添加到它的内容。

我添加了 time.sleep() 函数，这是一个非常糟糕的修复程序，到 30 年代，两个队列都已填满而不会耗尽。

解决此问题的标准 Python 方法是什么？我是否必须只有一个队列，并将其中的项目标记为应该由哪个线程处理？

queue = Queue.Queue()
out_queue = Queue.Queue()

class ThreadUrl(threading.Thread):
    """Threaded Url Grab"""
    def __init__(self, queue, out_queue):
        threading.Thread.__init__(self)
        self.queue = queue
        self.out_queue = out_queue

    def run(self):
        while True:
            row = self.queue.get()
            
            request = urllib2.Request(row[0], None, req_headers)
            
            # ... some processing ...
            
            self.out_queue.put([row, http_status, page])
            
            self.queue.task_done()

class DatamineThread(threading.Thread):
    def __init__(self, out_queue, mysql):
        threading.Thread.__init__(self)
        self.out_queue = out_queue
        self.mysql = mysql

    def run(self):
        while True:
            row …

编辑:用户@apocalisp和@BenjaminHodgson在下面留下了很棒的答案,跳过阅读大部分问题并跳转到他们的答案.

问题的TLDR:我怎样才能从FSM表示组合爆炸的第一张图片到第二张图片,在那里您只需要在继续之前访问所有这些图片.

我想构建一个有限状态机(真的在Haskell中,但我首先尝试使用Idris来查看它是否可以指导我的Haskell),其中有一些临时状态必须在达到最终状态之前访问.如果我可以通过某种状态的谓词任意约束FSM,那就太好了.

在下图中,有一个Initial州,3个临时州A, B, C和一个Final州.如果我没有弄错,在"正常"FSM中,您将始终需要n!临时状态来表示可能路径的每个组合.

这是不可取的.

相反,使用Type Families和可能的Dependent类型,我认为应该有一种状态可以随身携带,只有当它通过某些谓词时才允许你进入最终状态.(这是否会使自动推送自动机而不是FSM？)

到目前为止,我的代码(idris),通过类比,添加成分来制作沙拉,顺序无关紧要,但它们都需要在以下内容中实现:

data SaladState = Initial | AddingIngredients | ReadyToEat

record SaladBowl where
       constructor MkSaladBowl
       lettuce, tomato, cucumber : Bool

data HasIngredient : (ingredient : SaladBowl -> Bool) -> (bowl : SaladBowl ** ingredient bowl = True) -> Type where
     Bowl : HasIngredient ingredient bowl

data HasIngredients : (ingredients : List (SaladBowl …