小编cas*_*avo的帖子

我正在使用pandas来管理大量的8字节整数.这些整数作为空格分隔的元素包含在逗号分隔的CSV文件中,并且数组大小约为10000x10000.

Pandas能够快速读取前几列中逗号分隔的数据作为DataFrame,并且还可以轻松地将空格分隔的字符串存储在另一个DataFrame中.当我尝试将表从一列空格分隔的字符串转换为8位整数的DataFrame时,就会遇到麻烦.

我尝试过以下方法:

intdata = pd.DataFrame(strdata.columnname.str.split().tolist(), dtype='uint8')

但内存使用情况令人难以忍受 - 价值10MB的整数消耗2GB内存.我被告知这是语言的限制,在这种情况下我无能为力.

作为一种可能的解决方法,我被建议将字符串数据保存为CSV文件,然后将CSV文件重新加载为以空格分隔的整数的DataFrame.这很好用,但为了避免写入磁盘的速度减慢,我尝试写一个StringIO对象.

这是一个最小的非工作示例:

import numpy as np
import pandas as pd
from cStringIO import StringIO

a = np.random.randint(0,256,(10000,10000)).astype('uint8')
b = pd.DataFrame(a)
c = StringIO()
b.to_csv(c, delimiter=' ', header=False, index=False)
d = pd.io.parsers.read_csv(c, delimiter=' ', header=None, dtype='uint8')

这会产生以下错误消息:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/lib64/python2.7/site-packages/pandas/io/parsers.py", line 443, in parser_f
    return _read(filepath_or_buffer, kwds)
  File "/usr/lib64/python2.7/site-packages/pandas/io/parsers.py", line 228, in _read
    parser = TextFileReader(filepath_or_buffer, **kwds)
  File "/usr/lib64/python2.7/site-packages/pandas/io/parsers.py", line 533, …

当我尝试在gcc 4.8.2中编译以下代码时,我收到以下错误:

test.cc: In function ‘void foo(int*)’:
test.cc:15:16: error: no matching function for call to ‘begin(int*&)’
   for (int i : bar) {
                ^

Run Code Online (Sandbox Code Playgroud)

与模板库中更深层次的其他一些人一起.

#include <iostream>
using namespace std;

void foo(int*);

int main() {
  int bar[3] = {1,2,3};
  for (int i : bar) {
    cout << i << endl;
  }
  foo(bar);
}

void foo(int* bar) {
  for (int i : bar) {
    cout << i << endl;
  }
}

如果我重新定义foo使用索引for循环,那么代码将按预期编译和运行.此外,如果我将基于范围的输出循环移动到main,我也会得到预期的行为.

如何bar以foo一种能够在其上执行基于范围的for循环的方式传递数组？

我试图压扁嵌套的发电机发电机,但我得到了一个意想不到的结果:

>>> g = ((3*i + j for j in range(3)) for i in range(3))
>>> list(itertools.chain(*g))
[6, 7, 8, 6, 7, 8, 6, 7, 8]

我希望结果看起来像这样:

[0, 1, 2, 3, 4, 5, 6, 7, 8]

我想我得到了意想不到的结果,因为内部生成器在外部生成器已被迭代之前没有被评估,设置i为2.我可以通过使用列表推导强制评估内部生成器来解决一个解决方案生成器表达式:

>>> g = ([3*i + j for j in range(3)] for i in range(3))
>>> list(itertools.chain(*g))
[0, 1, 2, 3, 4, 5, 6, 7, 8]

理想情况下,我想要一个完全懒惰的解决方案,并且在使用之前不会强制评估内部嵌套元素.

有没有办法压缩任意深度的嵌套生成器表达式(可能使用其他东西itertools.chain)？

编辑:

不,我的问题不是类中生成器中的变量范围的重复.老实说,我不知道这两个问题是如何相关的.也许主持人可以解释为什么他认为这是重复的.

此外,我的问题的两个答案都是正确的,因为它们可以用来编写一个正确展平嵌套生成器的函数.

def flattened1(iterable):
    iter1, iter2 = …

C++标准提供div(int,int),但不提供udiv(unsigned int,unsigned int).

如果我天真地在这个函数中使用无符号整数,我可以看到这会对分子中大于2 ^ 31 - 1的整数产生错误的结果.例如(带有4位半字节):

最大的4位半字节是15,1111二进制.作为有符号的半字节,这将代表-1.将15除以2得到7或0111,但将-1除以2得到0:0000.

是否有一种直接的方法来将div调整为无符号整数,或者我最好是编写自己的udiv,还是完全避免使用div和div类函数？

编辑/注意:在我的情况下,我正在使用unsigned long long ints,所以使用lldiv并不能解决问题.

我对此感到困惑.我认为C++中的〜运算符应该以不同的方式工作(不是Matlab-y).这是一个最小的工作示例:

#include <iostream>
using namespace std;
int main(int argc, char **argv)
{
    bool banana = true;
    bool peach = false;
    cout << banana << ~banana << endl;
    cout << peach << ~peach << endl;
}

这是我的输出:

1-2
0-1

我希望有人能对此有所了解.

我是Haskell的新手,作为一个练习,我一直在努力实现Joel Franklin的" 计算方法在物理学"一书中的一些代码(用Mathematica编写).我编写了以下代码,将lambda表达式(加速度)作为第一个参数.通常,加速度的形式为x''= f(x',x,t),但并不总是所有三个变量.

-- Implementation 2.1: The Verlet Method
verlet _  _  _  _  0 = [] 
verlet ac x0 v0 dt n = take n $ zip [0,dt..] $ verlet' ac x0 v0 0 dt
  where verlet' ac x0 v0 t0 dt = 
          let
            xt = x0 + dt*v0 + 0.5*(dt^2)*(ac x0 v0 t0)
            vt = v0 + dt*(ac x0 v0 t0)
          in
            xt:(verlet' ac xt vt (t0+dt) dt)

在ghci中,我将使用以下命令运行此代码(加速函数a = - (2pi)² x来自书中的练习):

verlet (\x …

@property是定义 getter 的好方法。当属性是可变的时，返回的引用可用于以不受类定义控制的方式修改属性。我将使用香蕉架作为激励类比，但这个问题适用于任何包装容器的类。

class BananaStand:
    def __init__(self):
        self._money = 0
        self._bananas = ['b1', 'b2']

    @property
    def bananas(self):
        return self._bananas

    def buy_bananas(self, money):
        change = money
        basket = []
        while change >= 1 and self._bananas:
            change -= 1
            basket.append(self._bananas.pop())
            self._money += 1
        return change, basket

我希望香蕉摊的游客为他们的香蕉买单。不幸的是，没有什么能阻止一只猴子（谁也不知道更好）拿走我的一根香蕉。猴子不必使用内在属性_banana，他们只是不付钱就拿了一根香蕉。

def take_banana(banana_stand):
    return banana_stand.bananas.pop()

>>> stand = BananaStand()
>>> stand.bananas
['b1', 'b2']
>>> take_banana(stand)
'b2'
>>> stand.bananas
['b1']

这个类比有点愚蠢，但任何具有可变属性的类都无法防止意外破坏。在我的实际情况中，我有一个具有两个必须保持相同长度的数组属性的类。使用数组，没有什么能阻止用户将第二个数组拼接到第一个数组中，并无声地打破我的相等大小不变量：

>>> from array import array
>>> x = array('f', [1,2,3])
>>> x
array('f', …

我将Thue-Morse 序列的定义写为一行 Haskell 中的无限整数列表：

thueMorse = 0:1:f (tail thueMorse) where f = (\(x:xs) -> x:(1 - x):f xs)

这是尝试在一行中定义序列失败的结果，仅根据 lambda 表达式及其本身，没有 let 或 where 表达式（实际上应该在两行中呈现，使上述解决方案在精神上成为两行） ）。我已经阅读了一些有关 lambda 演算的内容，所以我想我应该尝试将其作为练习。我想知道 Haskell 中是否有可能实现这样的事情，如果可能的话该怎么做。

thueMorse = 0:1:(\f xs -> f f xs) (\f (x:xs) -> x:(1 - x):f f xs) ((\(_:xs) -> xs) thueMorse)

上面的表达式有点难以阅读，所以我将其分解：

(\f xs -> f f xs)

接受一个函数和一个参数，并将该函数应用于自身和参数。Haskell 不会计算这个表达式，因为 f 的类型是t = t -> a -> a，这是我问题的关键。

(\f (x:xs) -> x:(1 - x):f f xs)

是传递给前一个表达式的函数，它将自身和列表作为参数。这是递归计算 Thue-Morse …

我使用这个 pragmagetpid从 C导入：

function Get_Process_ID return Process_ID;
pragma Import (C, Get_Process_ID, "getpid");

我预计这会更难一些。要getpid在 C 中使用，我需要明确包含头文件 unistd.h；在上面的编译指示中，我没有引用头文件。GNAT 如何确切地知道在哪里可以找到getpid？

编辑：

这是一个最低限度的工作示例：

with Ada.Text_IO;

procedure Main is
   subtype Process_ID is Integer;
   function Get_Process_ID return Process_ID;
   pragma Import (C, Get_Process_ID, "getpid");   
begin
   Ada.Text_IO.Put_Line (Process_ID'Image (Get_Process_ID));
end Main;

保存为 main.adb，使用以下命令编译：

gnat make main.adb

我正在使用gnat来自 Ubuntu 18.04 软件存储库的全新安装的软件包，没有配置或项目文件。GNAT 版本是 7.5.0。

我写了一个小脚本来将黑板图片转换成我可以打印并标记的形式.

我拍这样的照片:

自动裁剪,并将其二值化.这是脚本的输出:

我想从图像中删除最大的连接黑色区域.有一个简单的方法吗？

我正在考虑侵蚀图像以消除文本,然后从原始二值化图像中减去侵蚀图像,但我不禁想到有更合适的方法.