在NumPy中,如何有效地将1-D对象制作成2-D对象,其中单个维度是从当前对象推断出来的(即列表应该是1xlength还是lengthx1向量)？
# This comes from some other, unchangeable code that reads data files.
my_list = [1,2,3,4]
# What I want to do:
my_numpy_array[some_index,:] = numpy.asarray(my_list)
# The above doesn't work because of a broadcast error, so:
my_numpy_array[some_index,:] = numpy.reshape(numpy.asarray(my_list),(1,len(my_list)))
# How to do the above without the call to reshape?
# Is there a way to directly convert a list, or vector, that doesn't have a
# second dimension, into a 1 by length "array" (but really it's still a …我继承了以Stata .dta格式保存的数据文件.我可以用scikits.statsmodels genfromdta()函数加载它.这将我的数据放入一维NumPy数组中,其中每个条目都是一行数据,存储在24元组中.
In [2]: st_time = time.time(); initialload = sm.iolib.genfromdta("/home/myfile.dta"); ed_time = time.time(); print (ed_time - st_time)
666.523324013
In [3]: type(initialload)
Out[3]: numpy.ndarray
In [4]: initialload.shape
Out[4]: (4809584,)
In [5]: initialload[0]
Out[5]: (19901130.0, 289.0, 1990.0, 12.0, 19901231.0, 18.0, 40301000.0, 'GB', 18242.0, -2.368063, 1.0, 1.7783716290878204, 4379.355, 66.17669677734375, -999.0, -999.0, -0.60000002, -999.0, -999.0, -999.0, -999.0, -999.0, 0.2, 371.0)
我很好奇是否有一种有效的方法将其安排到Pandas DataFrame中.根据我的阅读,逐行构建DataFrame看起来效率很低......但我的选择是什么？
我写了一个非常慢的第一遍,它只是将每个元组作为单行DataFrame读取并附加它.只是想知道是否还有其他更好的东西.
用相同的两个功能为什么id值有像不同的属性__doc__或__name__？
这是一个玩具示例:
some_dict = {}
for i in range(2):
def fun(self, *args):
print i
fun.__doc__ = "I am function {}".format(i)
fun.__name__ = "function_{}".format(i)
some_dict["function_{}".format(i)] = fun
my_type = type("my_type", (object,), some_dict)
m = my_type()
print id(m.function_0)
print id(m.function_1)
print m.function_0.__doc__
print m.function_1.__doc__
print m.function_0.__name__
print m.function_1.__name__
print m.function_0()
print m.function_1()
哪个印刷品:
57386560
57386560
I am function 0
I am function 1
function_0
function_1
1 # <--- Why is it bound to the most recent …我想在matplotlib中绘制一系列.png图像.目标是快速绘制它们以模拟电影的效果,但我有其他理由想要避免实际创建.avi文件或保存matplotlib图形,然后在Python之外按顺序查看它们.
我特意尝试在Python中的for循环中按顺序查看图像文件.假设我已正确导入matplotlib,并且我有自己的函数'new_image()'和'new_rect()',这里有一些示例代码无法工作,因为show()函数调用GUI mainloop的阻塞效果:
for index in index_list:
img = new_image(index)
rect = new_rect(index)
plt.imshow(img)
plt.gca().add_patch(rect)
plt.show()
#I also tried pausing briefly and then closing, but this doesn't
#get executed due to the GUI mainloop from show()
time.sleep(0.25)
plt.close()
上面的代码只能显示第一个图像,但程序只是挂起并等待我手动关闭结果图窗口.一旦我关闭它,程序就会挂起并且不会重新绘制新的图像数据.我该怎么办？另请注意,我已尝试使用plt.draw()命令替换plt.show()命令,然后在for循环外添加plt.show().这不会显示任何内容而只是挂起.
在Python中,是否可以完全封装常见的切片语法并传递它？我知道我可以使用slice或__slice__模拟切片.但是我希望传递完全相同的语法,我将放在方括号中使用__getitem__.
例如,假设我编写了一个函数来返回列表的某些片段.
def get_important_values(some_list, some_condition, slice):
elems = filter(some_condition, some_list)
return elems[slice]
如果我手动传入切片对象,这可以正常工作:
In [233]: get_important_values([1,2,3,4], lambda x: (x%2) == 0, slice(0, None))
Out[233]: [2, 4]
但是我想让用户传递的内容与他们使用的切片完全相同__getitem__:
get_important_values([1,2,3,4], lambda x: (x%2) == 0, (0:-1) )
# or
get_important_values([1,2,3,4], lambda x: (x%2) == 0, (0:) )
显然这会产生语法错误.但有没有办法让这项工作,而不是为x:y:t类型切片编写我自己的迷你解析器,并强制用户将它们作为字符串传递？
动机
我可以让这个示例函数返回一些可直接切片的东西,例如filter(some_condition, some_list),这将是作为列表的整个结果.然而,在我的实际例子中,内部函数要复杂得多,如果我知道用户想要的切片,我可以大大简化计算.但是我希望用户不必多做额外的事情就可以提前告诉我切片.
在Haskell中,我可以导入一个由其名称或快捷方式名称限定的模块,如下所示:
import qualified Data.List as List
import qualified Data.Map
我还可以从模块中仅导入一组选定的函数,或者导入除选择集以外的所有函数,如下所示:
import Data.List (sort, intersperse)
import Data.Map hiding (findWithDefault)
是否可以导入一组特定的函数,import Data.List (sort, intersperse)如上例所示,但是要确保仍然以合格的方式识别函数,例如List.sort和List.intersperse？
虽然这不起作用,但这是我所要求的精神:
import qualified Data.List (sort, intersperse) as List
也许
import qualified Data.List as List (sort, intersperse)
在Python中,假设我有一个函数f,我想传递一些辅助参数(为简单起见,它只是第一个保持变量的参数).
这两种方式(如果有的话)之间有什么区别？
# Assume secondary_args and secondary_kwargs have been defined
import functools
g1 = functools.partial(f, *secondary_args, **secondary_kwargs)
g2 = lambda x: f(x, *secondary_args, **secondary_kwargs)
例如,在doc页面中partial,有这样的引用:
partial在类中定义的对象的行为类似于静态方法,并且在实例属性查找期间不会转换为绑定方法.
如果用于从提供给类的参数(在构造函数中或稍后通过函数)中创建类方法,lambda方法是否会受此影响？
我正在使用Python 2.7.3.
考虑一个带有自定义(虽然很糟糕)迭代和项目获取行为的虚拟类:
class FooList(list):
def __iter__(self):
return iter(self)
def next(self):
return 3
def __getitem__(self, idx):
return 3
举个例子,看看奇怪的行为:
>>> zz = FooList([1,2,3])
>>> [x for x in zz]
# Hangs because of the self-reference in `__iter__`.
>>> zz[0]
3
>>> zz[1]
3
但现在,让我们创建一个函数,然后执行参数解包zz:
def add3(a, b, c):
return a + b + c
>>> add3(*zz)
6
# I expected either 9 or for the interpreter to hang like the comprehension!
因此,参数解包以某种方式获取项数据,zz但不是通过使用其实现的迭代器迭代对象,也不是通过执行穷人的迭代器并调用__getitem__与对象一样多的项.
所以问题是:如果不通过这些方法,语法如何add3(*zz) …
据说 Haskell元组只是代数数据类型的不同语法.类似地,有一些示例说明如何使用元组重新定义值构造函数.
例如,Haskell中的Tree数据类型可能被写为
data Tree a = EmptyTree | Node a (Tree a) (Tree a)
可以像这样转换为"元组形式":
data Tree a = EmptyTree | Node (a, Tree a, Tree a)
Node第一个示例中的值构造函数tuple与第二个示例中的值构造函数有什么区别？ie Node a (Tree a) (Tree a)vs. (a, Tree a, Tree a)(除了语法之外)？
在引擎盖下,Node a (Tree a) (Tree a)每个位置的3元组适当类型只是一种不同的语法？
我知道你可以部分应用一个值构造函数,例如Node 5它将具有类型:(Node 5) :: Num a => Tree a -> Tree a -> Tree a
您也可以使用(,,)函数来部分应用元组...但是这不知道未绑定条目的潜在类型,例如:
Prelude> :t (,,) 5
(,,) 5 …当我要求类似的东西时,按顺序执行的具体代码是什么
>>> 1 <= 3 >= 2
True
如果两者具有相同的优先权并且只是它们的评估顺序,为什么第二个不等式起(3 >= 2)代替(True >= 2)
考虑一下这些之间的区别
>>> (1 < 3) < 2
True
>>> 1 < 3 < 2
False
它只是一个纯粹的语法快捷方式硬编码到Python中,以扩展第二个作为and两个语句？
我可以改变一个类的这种行为,以便a <= b <= c扩展到不同的东西吗？它看起来像以下情况
a (logical operator) b (logical operator) c
--> (a logical operator b) and (b logical operator c)
但真正的问题是如何在代码中实现它.
我很好奇,这样我可以复制这种__lt__与__gt__行为在一些我自己的类,但我感到困惑,这是如何实现的固定中部参数不变.
这是一个具体的例子:
>>> import numpy as np
>>> tst = np.asarray([1,2,3,4,5,6])
>>> 3 <= tst
array([False, False, …