我有一个numpy数组:

m = array([[4, 0, 9, 0],
          [0, 7, 0, 0],
          [0, 0, 0, 0],
          [0, 0, 0, 5]])

m列的4列标记为:

c = array([ 10, 20, 30, 40])

我希望能够切割一个对象o:

o.vals[0,:] = array([4, 9])
o.vals[1,:] = array([7,])
o.vals[2,:] = array([])
o.vals[3,:] = array([5])
o.cols[0,:] = array([10, 30] )# the non-zero column labels from row 0
o.cols[1,:] = array([20,])
o.cols[2,:] = array([])
o.cols[3,:] = array([40])

是否有现成的Python对象可以让我这样做？

我看过Scipy Sparse Matrices,但它并不是我想要的.

2015年8月17日的最新消息:我已经有了一些想法,想出了这个,这与我上周描述的几乎相同:

• https://github.com/jsphon/NumericalFunctions/blob/master/jagged_array/JaggedKeyValueArray.rst

• https://github.com/jsphon/NumericalFunctions/blob/master/jagged_array/jagged_key_value_array.py

我试图在linux下使用Python来理解FIFO,我发现了一个我不理解的奇怪行为.

以下是 fifoserver.py

import sys
import time

def readline(f):
    s = f.readline()
    while s == "":
        time.sleep(0.0001)
        s = f.readline()
    return s

while True:
    f = open(sys.argv[1], "r")
    x = float(readline(f))
    g = open(sys.argv[2], "w")
    g.write(str(x**2) + "\n")
    g.close()
    f.close()
    sys.stdout.write("Processed " + repr(x) + "\n")

这是 fifoclient.py

import sys
import time

def readline(f):
    s = f.readline()
    while s == "":
        time.sleep(0.0001)
        s = f.readline()
    return s

def req(x):
    f = open("input", "w")
    f.write(str(x) + "\n")
    f.flush()
    g = open("output", …

在开发网络时,我一直在与奇怪的限制作斗争.其中一个是AJAX请求的同源限制,我问自己,如果不是阻止对跨域资源的请求,那么在制作cookie时就不会简单地丢弃cookie(以避免滥用身份验证凭据)浏览器会话).

Cookie是一种设施,但并不是必需的(例如,如果您需要保留上下文,您可以在请求URL中生成带有cookie的页面),而跨域阻止则非常烦人.

从逻辑的角度看,在阻止某个特定主题访问资源时,从某种程度上来说,我认为非常奇怪,实际上全世界的其他人都可以在没有身份验证的情况下访问该资源.

我想知道是否有一些真正的技术原因,相同的原产地政策真的是最好的解决方案.

请注意,我只是出于好奇而要求......我完全清楚,在网络时代,可怕的解决方案可以在标准中得到明确,然后才有可能证明它们是好还是坏(相当大的一部分)例如,Javascript).

以下代码块成功执行.我想知道除了使用for循环之外,这个标签的用途是什么？

<script>

js:
{
   alert("x");  
}

</script>

我想x将某个片段中的所有符号展开(value x).例如

(lambda ()
  (* x x))

应该成为

(lambda ()
  (* (value x) (value x)))

简单的使用是symbol-macrolet行不通的,因为

(symbol-macrolet ((x (value x)))
  (lambda ()
    (* x x)))

在宏扩展期间爆炸成无限递归,因为扩展的结果symbol-macrolet再次被处理以用于宏扩展,包括相同的扩展symbol-macrolet.

甚至试图扩大x至(value y),然后y到x不工作.例如:

(symbol-macrolet ((y x))
  (symbol-macrolet ((x (value y)))
    (lambda () (* x x))))

在SBCL的宏扩展时间仍然崩溃.

有没有办法只在没有完整代码行走的情况下扩展符号一次？

在文档中defaultdict有这个例子:

>>> def constant_factory(value):
...     return itertools.repeat(value).next

作为"更快,更灵活的创建常数功能的方式".

这是如何优越的

def constant_factory(value):
    return lambda : value

？

请注意,当然没有人会为此定义一个函数...只是使用(lambda: 42)比调用更清晰,更短的类型constant_factory(42).

为了创建一个常量工厂返回一个mutable,如果需要的话可以使用(lambda x=[]:x)(顺便说一句,这是可以做的constant_factory([]),但它经常咬回来的东西......参见例如这个问题).

我有一个十六进制数字0x8F(二进制10001111).我想改变那个值,所以新的值将是0xC7(11000111).我尝试过:

unsigned char x = 0x8F;
x=x>>1; 

但不是0xC7我得到了0x47？关于如何做到这一点的任何想法？

我可以使用哪种算法来搜索n个光盘（x _j，y _j，r _j）覆盖XY平面有限区域的最佳（最小面积）？

我发现有许多关于固定半径光盘的研究，但关于可变半径却没有任何研究。

n固定，但光盘可以自由放置（它们不在指定的位置，并且它们的中心不需要在区域内）。该区域通常是非连接和非简单连接的（可以由多个部分组成并且可以具有孔）。在我的特定情况下，是由多个封闭的多边形定义的（使用奇偶填充规则）。

回顾一下：

输入：

• XY平面的有限区域（例如，描述为具有奇偶填充规则的闭合多边形的集合）

• n> 0 的整数

输出：

• n用中心x[i], y[i]和半径描述的光盘列表，r[i]以便该区域的每个点都包含在至少一张光盘中

最小化：

• 圆盘结合所覆盖的平面区域

例

在此示例中，输入为“ A”形。手动放置十个点，并计算出覆盖该区域与Voronoi单元的交点的最小圆。

我目前正在研究仅基于寻找中心x[i], y[i]并r[i]使用此算法计算半径的方法（搜索空间减少？ⁿ并始终产生可接受的解决方案）。

我想测试特定类型的随机矩阵在有限域上是否可逆,特别是F_2.我可以使用以下简单代码测试矩阵在实数上是否可逆.

import random
from scipy.linalg import toeplitz
import numpy as np
n=10
column = [random.choice([0,1]) for x in xrange(n)]
row = [column[0]]+[random.choice([0,1]) for x in xrange(n-1)]
matrix = toeplitz(column, row)
if (np.linalg.matrix_rank(matrix) < n):
    print "Not invertible!"

有没有办法实现同样的事情,但超过F_2？

我想要一种向量化特征值计算的numpy-sh方式,这样我就可以给它一个矩阵矩阵,它将返回各个特征值的矩阵.

例如,在下面的代码中,B是由3x3矩阵A的4个副本组成的块6x6矩阵.C是我想看到的输出,即维数(2,2,3)的数组(因为A有3个特征值).

这当然是一个非常简化的例子,在一般情况下,矩阵A可以具有任何大小(尽管它们仍然是正方形),并且矩阵B不一定由A 的副本形成,而是不同的A1,A2等(所有相同大小但包含不同的元素).

import numpy as np
A = np.array([[0, 1, 0],
              [0, 2, 0],
              [0, 0, 3]])
B = np.bmat([[A, A], [A,A]])
C = np.array([[np.linalg.eigvals(B[0:3,0:3]),np.linalg.eigvals(B[0:3,3:6])],
              [np.linalg.eigvals(B[3:6,0:3]),np.linalg.eigvals(B[3:6,3:6])]])