小编Mic*_*ael的帖子

我正在使用一堆大型numpy数组,并且由于这些数组最近开始咀嚼太多内存,我想用numpy.memmap实例替换它们.问题是,我现在必须调整阵列的大小,我最好这样做.这对于普通数组非常有效,但是在memmaps上尝试这一点会抱怨,数据可能会被共享,甚至禁用重新检查也无济于事.

a = np.arange(10)
a.resize(20)
a
>>> array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

a = np.memmap('bla.bin', dtype=int)
a
>>> memmap([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

a.resize(20, refcheck=False)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-41-f1546111a7a1> in <module>()
----> 1 a.resize(20, refcheck=False)

ValueError: cannot resize this array: it does not own its data

调整底层mmap缓冲区的大小非常合适.问题是如何将这些更改反映到数组对象.我已经看到了这种解决方法,但不幸的是它没有调整阵列的大小.还有一些关于调整mmaps大小的numpy文档,但它显然不起作用,至少对于1.8.0版本.任何其他想法,如何覆盖内置的大小调整检查？

我知道神奇的IPython %paste命令,如果你有有效的代码插入,这是非常有用的.现在我不想插入代码,我只想将复制缓冲区中的一些字符串存储为变量.有没有更简单的方法,除了将字符串复制到一些单独的文本编辑器并首先修改它？

像这样的东西会很好,但它们都不起作用:

strvar = %paste
strvar = """%paste"""

PS字符串很长,包含特殊的字符等.所以简单的ctrl-c只会创建垃圾和错误消息.

我在IPython中处理一些GB大小的numpy数组.当我删除它们时,我肯定希望它们消失,以便恢复内存.IPythons输出缓存在那里非常烦人,因为它甚至在删除了最后一个主动预期的对它们的引用后仍保持对象存活.我已经开始了

c.TerminalInteractiveShell.cache_size = 0

在IPython配置中,但这仅禁用条目的缓存,仍然创建_oh其他变量_,__依此类推.我也知道%xdel,但无论如何,我宁愿完全禁用它,因为我很少使用输出历史,所以平原del会立即再次运行.

标准的numpy圆形打破遵循IEEE 754惯例,朝着最接近的偶数舍入一半.有没有办法指定不同的舍入行为,例如舍入为零或朝向-inf？我不是在谈论ceil或者地板,我只需要不同的打破领带.

在我的程序中,我正在使用不同大小的各种numpy数组.我需要将它们存储到XML文件中以供以后使用.我没有将它们写入二进制文件,因此我将所有数据放在一个地方(XML文件)而不是分散在200个文件中.

所以我尝试使用numpy的array_str()方法将数组转换为String.生成的XML如下所示:

-<Test date="2013-07-10-17:19">
    <Neurons>5</Neurons>
    <Errors>[7.7642140551985428e-06, 7.7639131137987232e-06]</Errors>
    <Iterations>5000</Iterations>
    <Weights1>[[ 0.99845902 -0.70780512 0.26981375 -0.6077122 0.09639695] [ 0.61856711 -0.74684913 0.20099992 0.99725171 -0.41826754] [ 0.79964397 0.56620812 -0.64055346 -0.50572793 -0.50100635]]</Weights1>
    <Weights2>[[-0.1851452 -0.22036027] [ 0.19293429 -0.1374252 ] [-0.27638478 -0.38660974] [ 0.30441414 -0.01531598] [-0.02478953 0.01823584]]</Weights2>
</Test>

权重是我想要存储的值.现在问题是numpy的fromstring()方法显然不能重新加载这些......我得到"ValueError:字符串大小必须是元素大小的倍数"

我用"np.array_str(w1)"编写它们并尝试用"np.fromstring(w_str1)"读取它们.显然结果只是一维数组,即使它工作,所以我必须手动恢复形状.呃,这已经是一种痛苦,因为我也必须以某种方式存储它.

这样做的最佳方法是什么？最好还可以保存我的阵列的形状和数据类型,而不需要手动管理每个小东西.

我最近偶然发现了numba,并考虑用更优雅的autojitted python代码替换一些自制的C扩展.不幸的是,当我尝试第一个快速基准时,我并不高兴.看起来numba在这里并没有比普通的python好多少,虽然我本来期待几乎类似C的性能:

from numba import jit, autojit, uint, double
import numpy as np
import imp
import logging
logging.getLogger('numba.codegen.debug').setLevel(logging.INFO)

def sum_accum(accmap, a):
    res = np.zeros(np.max(accmap) + 1, dtype=a.dtype)
    for i in xrange(len(accmap)):
        res[accmap[i]] += a[i]
    return res

autonumba_sum_accum = autojit(sum_accum)
numba_sum_accum = jit(double[:](int_[:], double[:]), 
                      locals=dict(i=uint))(sum_accum)

accmap = np.repeat(np.arange(1000), 2)
np.random.shuffle(accmap)
accmap = np.repeat(accmap, 10)
a = np.random.randn(accmap.size)

ref = sum_accum(accmap, a)
assert np.all(ref == numba_sum_accum(accmap, a))
assert np.all(ref == autonumba_sum_accum(accmap, a))

%timeit sum_accum(accmap, a)
%timeit autonumba_sum_accum(accmap, a)
%timeit numba_sum_accum(accmap, …

我目前正在学习Python的艰难之路.我想这个例子可能已经过时了,所以我想在这里得到反馈.

我正在使用Python 3.1

from sys import argv

script, first, second, third = argv

print("the script is called:", (script))
print("your first variable is:", (first))
print("your second variable is:", (second))
print("your third variable is:", (third))

我收到这个错误:

Traceback (most recent call last):
  File "/path/ch13.py", line 3, in <module>
    script, first, second, third, bacon = argv
ValueError: need more than 1 value to unpack

知道什么是错的吗？

当我在Python中打开网络连接时

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('www.heise.de', 80))

我可以从控制台读取连接状态:

netstat --all --program|grep <PID>
tcp   0  0 10.10.10.6:39328   www.heise.de:http  VERBUNDEN  23829/python

但是如何从Python中读取此连接状态,CONNECTED,CLOSE_WAIT ...... 通过套接字文档阅读没有给我任何暗示.

我想在另一个数组中定义的组边界内对数组进行排序.这些组不以任何方式进行预分类,并且在分类后需要保持不变.在numpy方面,它应该是这样的:

import numpy as np

def groupwise_sort(group_idx, a, reverse=False):
    sortidx = np.lexsort((-a if reverse else a, group_idx))
    # Reverse sorting back to into grouped order, but preserving groupwise sorting
    revidx = np.argsort(np.argsort(group_idx, kind='mergesort'), kind='mergesort')
    return a[sortidx][revidx]

group_idx =   np.array([3, 2, 3, 2, 2, 1, 2, 1, 1])
a =           np.array([3, 2, 1, 7, 4, 5, 5, 9, 1])
groupwise_sort(group_idx, a)
# >>>            array([1, 2, 3, 4, 5, 1, 7, 5, 9])
groupwise_sort(group_idx, a, reverse=True)
# >>>            array([3, 7, …

我想使用自定义SQLalchemy数据类型存储大量的python浮点时间戳作为标准postgresql时间戳.我看到了可能的解决方案,例如使用带有mysql unix时间戳的sqlalchemy定义表.我不喜欢它,它是相当低效的,因为它将浮点数转换为时间对象,然后返回到时间戳,而这应该只是"乘以1e6,添加常量并转换为int" - 转换,应该在时间上接近一个noop.而

%timeit float(calendar.timegm(datetime.datetime.utcfromtimestamp(1542098001).timetuple()))

在我的机器上每次通话浪费了2us.使用postgresql to_timestamp,extract(epoch from timestamp_col)应该更快,更适合分析工作负载.SQLalchemy中是否有一种方法可以自动对SQL级别的那些转换应用于影响该列的所有语句？我还考虑使用一个简单的浮点字段进行存储,但我更喜欢能够使用时间函数来访问数据.

import time
from datetime import datetime
from calendar import timegm
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from sqlalchemy import Column, String, Integer, DateTime, TypeDecorator, create_engine


class Timestamp(TypeDecorator):
    impl = DateTime

    def process_bind_param(self, value, dialect):
        if value is None:
            return
        elif isinstance(value, datetime):
            return value
        elif isinstance(value, (int, float)):
            return datetime.utcfromtimestamp(value)
        raise TypeError("Any form of time object required, but received {}".format(type(value).__name__))

    def process_result_value(self, value, …

编辑：这个问题已经严重过时了！现在Enum，numba支持并namedtuple提供了开箱即用的功能，它们都为分组常量提供了合理的解决方案。

我在python中做一些移位，想用numba加快速度。为此，我有很多常量整数值，必须以一种易于理解的方式进行处理。我想将它们组合在一起，成为枚举式对象，使所有常量在一个名称空间中，可以通过attribute-get运算符进行访问。当然，我也想让numba理解那里发生的事情，以便它可以通过jit编译保持高速。我首先也是最天真的尝试是这样的：

class SomeConstantsContainer:
    SOME_NAME = 0x1
    SOME_OTHER_CONSTANT = 0x2
    AND_ANOTHER_CONSTANT = 0x4

不幸的是，当我查看注解时，numba似乎不了解值是恒定的，并且总是回落到对python对象的慢速对象访问上。这就是注释所说的：

#   $29.2 = global(SomeConstantsContainer: <class 'constants.SomeConstantContainer'>)  :: pyobject
#   $29.3 = getattr(attr=SOME_VARIABLE, value=$29.2)  :: pyobject

我知道我总是会退缩到这样的地方：

from numpy import np
SOME_STUPID_CONSTANT = np.int64(0x1)
ANOTHER_STUPID_CONSTANT = np.int64(0x2)

在那种情况下，jit编译器a）不需要查找容器的属性，b）肯定知道它必须处理一个普通整数。这样写真是太丑了。我可以将所有常量明确标记为整数，或者让容器来做。尽管如此，我确实很想将这些常量归类在容器中，以使内容更加清晰，并且jit编译版本可以理解语法，并且不会在每次使用常量时都花一些时间进行缓慢的python属性查找。有没有更好的主意，如何使第二种方法更像第一种方法，同时又保持较高的执行速度？是否有一些numba可以理解的枚举容器，我只是错过了？

编辑：也使用新的enum容器是没有帮助的：

@enum.unique
class SomeConstantsContainer(enum.IntEnum):
    SOME_NAME = 0x1
    SOME_OTHER_CONSTANT = 0x2
    AND_ANOTHER_CONSTANT = 0x4

这给出：

    #   $42.3 = global(SomeConstantsContainer: <enum 'SomeConstantsContainer'>)  :: pyobject
    #   $42.4 = getattr(attr=SOME_OTHER_CONSTANT, value=$42.3)  :: pyobject

>>> start_date = date(1983, 11, 23)
>>> start_date.replace(month=start_date.month+1)
datetime.date(1983, 12, 23)

这个工作直到月份<=11,我一直这样做

>>> start_date = date(1983, 12, 23)
>>> start_date.replace(month=start_date.month+1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: month must be in 1..12

如何在12月新增月份时增加月份的增量？

我的功能遇到了一些麻烦.而不是返回所需的列表,我得到的东西看起来像一个内存地址.如果有人能够指出我出错的地方,那将是非常好的.

这是代码

def listing():
    t = [1, 2, 3, 4, 5]
    return t

m = listing
print m

这是我在命令行上得到的.

<function listing at 0x7f6d5f9f5a28>