小编use*_*636的帖子

我有一个功能.matchCondition(a),取整数并返回True或False.

我有一个10个整数的列表.我想返回列表中的第一个项目(与原始列表的顺序相同),matchCondition返回True.

尽可能诡异.

来自https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.Executor.map

如果 func 调用引发异常，则在从迭代器检索其值时将引发该异常。

以下代码段仅输出第一个例外 (Exeption: 1)，然后停止。这是否与上述说法相矛盾？我希望以下内容打印出循环中的所有异常。

def test_func(val):
  raise Exception(val)        

with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:   
  for r in executor.map(test_func,[1,2,3,4,5]):
    try:
      print r
    except Exception as exc:
      print 'generated an exception: %s' % (exc)

我有2个词:

dicts1 = {'field1':'', 'field2':1, 'field3':1.2}
dicts2 = {'field1':123, 'field2':123, 'field3':'123'}

我想将每个值转换dict2为与相应值相同的类型dict1,这是最快的pythonic方式吗？

如果我有两个变量,a和b,它们可以是整数,浮点数或字符串.

True如果它们相等,我想返回(如果是字符串,则忽略大小写).

尽可能像Pythonic.

可能重复:
将datetime.date对象转换为datetime.datetime对象,其中包含任意缺失时间属性的零

如何将datetime.dateobj转换为datetime.datetimeobj,默认为午夜？

问题陈述:

方程以格式给出A / B = k,其中A和B是表示为字符串的变量,并且k是实数(浮点数).

给出一些查询,返回答案.如果答案不存在,则返回-1.0.

示例:给定 a / b = 2.0, b / c = 3.0.

查询是:a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ? 返回 [6.0, 0.5, -1.0, 1.0, -1.0 ]

输入是:

vector<pair<string, string>> equations
vector<double>& values
vector<pair<string, string>> queries 

在哪里equations.size() == values.size(),价值是积极的.

这代表方程式.

返回vector<double>.

根据上面的例子:等式= [ ["a", …

题:

给定两个单词(beginWord和endWord)和一个字典的单词列表,找到从beginWord到endWord的所有最短变换序列,这样:

一次只能更改一个字母.每个转换后的单词必须存在于单词列表中.请注意,beginWord不是转换后的单词.

例1:

输入:beginWord ="hit",endWord ="cog",wordList = ["hot","dot","dog","lot","log","cog"]

输出:[["hit","hot","dot","dog","cog"],["hit","hot","lot","log","cog"]]

我的解决方案基于这个想法,但我如何分析此解决方案的时间和空间复杂性？

1)通过将每个字母转换为26个字母中的一个来执行从beginWord开始的BFS,并查看转换后的单词是否在wordList中,如果是,则放入队列.

2)在BFS期间,为所有有效的下一个单词维护{word:nextWord}的图形

3)当nextWord到达endWord时,在图形上进行回溯DFS(预先遍序遍历)以获得所有路径.

class Solution:
    def findLadders(self, beginWord, endWord, wordList):
        """
        :type beginWord: str
        :type endWord: str
        :type wordList: List[str]
        :rtype: List[List[str]]
        """
        wordListSet = set(wordList+[beginWord])
        graph = collections.defaultdict(list)
        q = set([beginWord])    
        count = 0
        result = []
        while q:
            count +=1
            newQ = set()
            for word in q:
                wordListSet.remove(word)
            for word in q:
                if word == endWord:                                        
                    self.getAllPaths(graph, beginWord, endWord, result, [])
                    return result
                for i in range(len(word)): …

我有:

try:
   ...
except Exception, e:
   print "Problem. %s" % str(e)

但是,在尝试的某个地方,我需要它表现得好像遇到了异常.这样做是不是pythonic的:

try:
   ...
   raise Exception, 'Type 1 error'
   ...

except Exception, e:
   print "Problem. Type 2 error %s" % str(e)

将此视为现代系统设计范例的调查:

假设我已经编写了一个程序来返回给定数字的总和.我们称之为Amazing Adder.我的目标是让这个神奇的加法器可供其他人使用.截至2018年,将这款Amazing Adder作为公开服务提供给全世界的主流和现代方式是什么？我对后端架构更感兴趣,而不是用户界面.根据我对系统设计的了解,我可以想到:

1)使这成为一个REST服务,但这个用例是否适合REST范例？我该怎么称呼我的终端？如果我正在做的是添加没有状态信息的数字,我需要支持哪些操作(更新,删除等)？

2)通过http制作这个普通的JSON RPC.因此,用户向http://www.theAmazingAdder.com/add发送http POST请求,有效负载为{'number1':2,"number2":3},我的服务将返回{'sum':3 }

3)通过Profobuf或Thrift使其成为二进制RPC格式.那有点矫枉过正吗？客户端和服务器必须具有的"代码定义"是什么？

4)传统的Python pickling或java序列化/ rmi via network？那是否合适？

我错过了其他任何流行的现代范例吗？

从系统设计/可伸缩性的角度来看,在处理需要大量写入数据库中特定表的系统时,有哪些行业标准策略.

为简单起见,假设该表是产品的库存表,并且具有"产品名称"列和"计数"列,并且每次将新产品购买到系统时它只增加+1.每隔2天有数百万用户购买不同的产品,我们必须跟踪每种产品的最新数量,但不一定要严格实时,也许可以接受5分钟的延迟.

我的选择是:

1)主从复制,其中主DB处理所有写入,而从属处理读取.但这并没有解决写得很重的问题

2)根据产品名称范围或其散列值对数据库进行分片.但是,如果某个特定产品(例如Apple)在短时间内收到大量更新,那么它仍然会遇到相同的数据库.

3)批量更新？使用某种缓存并每隔X秒写入表格,累计计算我们在这些X秒内收到的任何数据？这是一个有效的选项,我使用什么缓存机制？如果上次读取和下次写入之间发生崩溃怎么办？如何恢复丢失的计数？

4)我忘记了任何其他明显的选择？

任何见解都表示赞赏!