Eureka在Python中的时刻 [英] Eureka moments in Python
问题描述
我有兴趣听听人们关于Eureka在Python中的时刻的故事，
你突然意识到某些任务看起来像什么的时候
使用Python会很容易的工作。
我最近有一个，我花了一些时间创建一个函数
将列表作为一个列表参数，然后重新排列项目按照
魔术师称之为Monge shuffle。我开始使用一段
代码走进列表，将项目放入两个新列表，然后
再次组合它们。我把代码缩小到八行左右，这样的东西
就像这样：
＃来自内存，未经测试
top， bottom = True，False＃不是严格需要的，但有助于文档代码
where = bottom
holder = {top：[]，bottom：[]}
for reverse（alist）中的项目：
持有人[where] .append（item）
where = not where
holder [底部] .reverse（）
打印支架[底部] +支架[顶部]
然后它突然让我觉得我可以做一个单线程：
alist [1 :: 2] + list（reverse（alist [0 :: 2]））
或者如果我想要更简洁，如果可读性稍差：
alist [1 :: 2] + alist [0 :: 2] [:: - 1]
>
如果只有真正的Monge随身携带实际卡牌那么容易......
-
Steven D'' Aprano
Steven D''Aprano写道：
我有兴趣听听人们关于Eureka在Python中的时刻的故事，
你突然意识到某些任务看起来像什么的时候
$ b $用Python很难做到很辛苦。
当我第一次使用xmlrpc模块的时候，我的确是绝对的。
我很困惑，我到底是怎么回事当该方法不存在时，能够调用对象的
方法。所有谈论
Python是一种动态语言，直到那一刻我才退出，
当我在调试器中走过__getattr__方法时，
是
开明。
毫不奇怪，这也是C ++开始感觉像我这样的直接夹克的时刻......
3月13日上午10点05分，Brett g Porter< bgpor ... @ acm.orgwrote：
Steven D''Aprano写道：
我有兴趣听听人们关于Python中尤里卡时刻的故事，
当你突然意识到某些看起来像是b $ b的任务将是辛苦的工作很容易用Python。
当我第一次使用xmlrpc模块时，我的确是绝对的。
我很困惑，我到底是怎么回事当该方法不存在时，能够调用对象的
方法。所有谈论
Python是一种动态语言，直到那一刻我才退出，
当我在调试器中走过__getattr__方法时，
是
开明。
毫不奇怪，这也是C ++开始感觉像我这样的b $ ba直筒衣的时刻...
开始了？意思是有一段时间它感觉像是一件
的紧身衣？如果我是一名记者，这将是
新闻...
3月13日，2：16 am，Steven D''Aprano< s ... @ REMOVEME.cybersource.com.au>
写道：
我'有兴趣听听人们关于Eureka在Python中的时刻的故事，
当你突然意识到某些看起来像是b $ b b b的任务将是艰苦的工作时使用Python很容易。
##我有这个问题，给出一个非零的列表
##正整数（sv） ，我需要计算三个常数
## x，y，z其中
##
## x是2加权sv中元素总和的数量，
##
## y是3增加到sv中元素数的幂，
##
##和
##
## z是3 ** a * 2 ** A + 3 * * b * 2 ** B + ... + 3 ** m * 2 ** M + 3 ** n * 2 ** N
##
##其中a，b，... m，n为0,1，... len（sv）-2，len（sv）-1和
## N是除了最后一个之外的sv的所有元素的总和，
## M是除了最后两个之外的sv的所有元素的总和，
＃ ＃...
## B是除了最后一个len（sv）-1之外的所有sv元素的总和，
## A是所有元素的总和sv除了最后一个len（sv）。
##
##原来这是'
$ b $的东西之一b ##比编码更容易编码。
##
##如果你看到我原来的Excel电子表格我在哪里
##开发它，你也会说Eureka。
def calc_xyz（sv）：
x = 2 ** sum（sv）
$ b $ = 3 ** len（sv）
z = 0
$ x $ b for x in xrange（len（sv））：
z + = 3 ** i * 2 **总和（sv [:-（i + 1）]）
返回（x，y，z）
sv = [1,2,3,4]
print calc_xyz（sv）
##（1024,81,133）
I''d be interested in hearing people''s stories of Eureka moments in Python,
moments where you suddenly realise that some task which seemed like it
would be hard work was easy with Python.
I had a recent one, where I had spent some time creating a function which
took a list as an argument, and then rearranged the items according to
what magicians call a Monge shuffle. I had started off with a piece of
code that walked the list, dropping items into two new lists, then
combining them again. I got the code down to eight lines or so, something
like this:
# from memory, untested
top, bottom = True, False # not strictly needed, but helps document code
where = bottom
holder = {top: [], bottom: []}
for item in reversed(alist):
holder[where].append(item)
where = not where
holder[bottom].reverse()
print holder[bottom] + holder[top]
And then it suddenly struck me that I could do it as a one-liner:
alist[1::2] + list(reversed(alist[0::2]))
Or if I wanted to be even more concise, if slightly less readable:
alist[1::2] + alist[0::2][::-1]
If only a real Monge shuffle with actual cards was so easy...
--
Steven D''Aprano
解决方案Steven D''Aprano wrote:I''d be interested in hearing people''s stories of Eureka moments in Python,
moments where you suddenly realise that some task which seemed like it
would be hard work was easy with Python.Mine was definitely when I was first working with the xmlrpc module, and
I was puzzled to no end how it was that I was able to make a call to a
method of an object when that method didn''t exist. All the talk about
Python being a dynamic language had bounced off of me until that moment,
when I walked through the __getattr__ method in the debugger and was
enlightened.
Not surprisingly, that was also the moment when C++ started feeling like
a straightjacket to me...
On Mar 13, 10:05 am, Brett g Porter <bgpor...@acm.orgwrote:Steven D''Aprano wrote:I''d be interested in hearing people''s stories of Eureka moments in Python,
moments where you suddenly realise that some task which seemed like it
would be hard work was easy with Python.
Mine was definitely when I was first working with the xmlrpc module, and
I was puzzled to no end how it was that I was able to make a call to a
method of an object when that method didn''t exist. All the talk about
Python being a dynamic language had bounced off of me until that moment,
when I walked through the __getattr__ method in the debugger and was
enlightened.
Not surprisingly, that was also the moment when C++ started feeling like
a straightjacket to me...Started? Meaning there was a time when it DIDN''T feel like a
straightjacket? If I were a journalist, this would be all over the
news...
On Mar 13, 2:16 am, Steven D''Aprano <s...@REMOVEME.cybersource.com.au>
wrote:I''d be interested in hearing people''s stories of Eureka moments in Python,
moments where you suddenly realise that some task which seemed like it
would be hard work was easy with Python.
## I have this problem where, given a list of non-zero
## positive integers (sv), I need to calculate threee constants
## x, y, z where
##
## x is 2 raised to the power of the sum of the elements in sv,
##
## y is 3 raised to the power of the count of the elements in sv,
##
## and
##
## z is 3**a*2**A + 3**b*2**B + ... + 3**m*2**M + 3**n*2**N
##
## where a,b,...m,n are 0,1,...len(sv)-2,len(sv)-1 and
## N is the sum of all elements of sv except the last one,
## M is the sum of all elements of sv except the last two,
## ...
## B is the sum of all elements of sv except the last len(sv)-1,
## A is the sum of all elements of sv except the last len(sv).
##
## This turned out to be one of those things that''s
## easier to code than to describe.
##
## And if you saw my original Excel spreadsheet where I
## developed it, you''d say Eureka too.
def calc_xyz(sv):
x = 2**sum(sv)
y = 3**len(sv)
z = 0
for i in xrange(len(sv)):
z += 3**i * 2**sum(sv[:-(i+1)])
return (x,y,z)
sv = [1,2,3,4]
print calc_xyz(sv)
## (1024, 81, 133)
这篇关于Eureka在Python中的时刻的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
