小编Bro*_*eph的帖子

我正在尝试编写一个BitArray类,并且拥有像numpy的数组这样的东西会非常好x[i:j:k] = val.

我怎么用Python写这个？不是__setslice__,对吗？因为这只需要三个参数,我需要一个拿四个.

我正在Python 3.6中编写一个分形生成器，并使用multiprocessing.Queues将消息从主线程传递给工作程序。到目前为止，这是我尝试过的方法，但是PyCharm似乎无法推断出从队列中获取的项目的属性类型：

from typing import NamedTuple, Any, Generic, TypeVar, Tuple
from multiprocessing import Process, Queue

T = TypeVar()


class Message(NamedTuple):
    method: str
    id: str
    data: Any = None


class TypedQueue(Generic[T]):
    def get(self) -> T:
        ...
    def put(self, m: T) -> None:
        ...


MessageQ = TypedQueue[Message]


class FractalWorker(Process):
    def __init__(self, work: MessageQ, results: MessageQ)
        super().__init__()
        self.work = work
        self.results = results

    @staticmethod
    def make_queues() -> Tuple[MessageQ, MessageQ]:
        work = cast(MessageQ, Queue())
        results = cast(MessageQ, Queue())
        return work, results

我希望PyCharm能够告知结果的属性 …

我有这样的结构:

typedef struct{
    size_t length; // length of the array
    size_t numbits; // number of bits allocated per val in vals
    mpz_t vals[]; // flexible array to hold some number of mpz_t array
} CoolArray;

好的,所以它是一个普通的灵活数组,我应该可以使用malloc来设置它的大小:

void initArray(CoolArray* array, size_t length, size_t numbits){
    assert(length>=1); // don't make arrays with a length<=0

    // first I allocate memory for vals...
    array->vals = (mpz_t*) malloc(sizeof(CoolArray)+length*sizeof(mpz_t));

    // then I allocate memory for each val in vals
    mpz_array_init(array->vals, (size_t)length, numbits);

    return;
}

但是当我尝试使用它时,我遇到了分段错误.我也抱怨有关错误使用mpz_array_init的问题.但是我看过manula,看来我正在这样做.

我也尝试使用我的结构:

typedef …

我最近决定研究大整数的因子算法,这种"分而治之"的算法比简单的迭代方法和素因子方法更快:

def multiply_range(n, m):
    print n, m
    if n == m:
        return n
    if m < n:
        return 1
    else:
        return multiply_range(n, (n+m)/2) * multiply_range((n+m)/2+1, m)

def factorial(n):
    return multiply_range(1, n)

我理解为什么算法有效,它只是递归地将乘法分成更小的部分.我不明白的是为什么这种方法更快.

我正在使用NamedTuples来保存数据，并且我想添加一个可以被多个NamedTuple基础类继承的方法。但是，当我尝试使用多个继承或NamedTuple基于子类的类时，它不起作用。具体来说，我试图为所有数据类自动提供一种方法，该方法可以查看类注释，然后基于此方法调用一些序列化代码。以下是我尝试过的一些示例：

from typing import NamedTuple


class Base1:
    def foo(self):
        print(self.__annotations__)


class Test1(NamedTuple, Base1):
    x: int
    y: int


x = Test1(1, 2)
x.foo() # raises AttributeError


class Base2(NamedTuple):
    def foo(self):
        print(self.__annotations__)


class Test2(Base2):
    x: int
    y: int


x = Test2(1, 2) # TypeError: __new__() takes 1 positional argument but 3 were given

我有办法使用这样的NamedTuple课程吗？

我在某处读到了在python中定义函数内部的函数是不好的,因为它使得python在调用外部函数的时候创建了一个新的函数对象.有人基本上这样说:

#bad
def f():
    def h():
        return 4
return h()

#faster
def h():
    return 4

def f(h=h):
    return h()

这是真的？另外,当我有这么多常量的情况怎么样:

x = # long tuple of strings
# and several more similar tuples
# which are used to build up data structures

def f(x):
    #parse x using constants above
    return parse dictionary

如果我将所有常量放在f的定义中,它会更快吗？或者我应该将它们留在外面并将它们绑定到关键字参数中的本地名称？不幸的是,我没有任何数据可以做时间,所以我想我问的是你有类似事情的经历.

所以我只是在使用python中的套接字.根据getsockopt函数,我发现将套接字选项SO_RECVBUF设置为N会使套接字recv缓冲区变为2N字节大.例如:

import socket
a, b = socket.socketpair()
a.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 4096)
print a.getsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF) #prints 8192
b.send('1'*5000)
print len(a.recv(5000)) #prints 5000 instead of 4096 or something else.

a.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 8192)
print a.getsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF) #prints 16384

谁可以给我解释一下这个？我正在写一个HTTP服务器,我想严格限制请求的大小,以保护我珍贵的RAM数量.

我正在尝试编写像zip这样的函数.我不善于解释我的意思,所以我只会展示我正在尝试做的"代码".

a = [1,2,3,[4,5]]
b = a[:]
zip(a, b) == [(1,1), (2,2), (3,3), ([4,5],[4,5])]
myzip(a, b) == [(1,1), (2,2), (3,3), [(4,4), (5,5)]]

我如此坚持这一点,甚至都不好笑.我试图用递归的lambdas以简单的函数方式编写它,以使我的代码更漂亮.我想要像这样的myzip,因为我想将其输出与我编写的另一个函数一起使用,该函数将函数映射到树

def tree_map(func, tree):
    return map(lambda x: func(x) if not isinstance(x, list) else tree_map(func, x), 
               tree)

我一直试图用拉链做类似的事情,但我似乎无法绕过它.有没有人对我如何写myzip有任何想法？

编辑:看看tree_map!不是很漂亮!我至少这么认为,但我的母语是Scheme:P,而且,我希望myzip尽可能深入.基本上,我希望myzip保留我传递的树的结构.此外,myzip只会处理相同形状的树.

我有这两个类:

class Shape(object):
    def __init__(self, start_point, *args):
        self.vertices = []
        self.__make_vertices(start_point, *args)

    def __make_vertices(self, start_point, *args):
        print "Not Implemented: __make_vertices"

    def __getitem__(self, *args):
        return self.vertices.__getitem__(*args)

class Cube(Shape):
    def __init__(self, start_point, side_length):
        Shape.__init__(self, start_point, side_length)

    def __make_vertices(self, start_point, side_length):
        append = self.vertices.append
        start_point = Vector(*(start_point))
        i, j, k = side_length*I, side_length*J, side_length*K
        append(start_point)
        append(self.vertices[-1] - k)
        append(self.vertices[-1] - j)
        append(self.vertices[-1] + k)
        append(self.vertices[-1] - i)
        append(self.vertices[-1] - k)
        append(self.vertices[-1] + j)
        append(self.vertices[-1] + k)
        print self.vertices

当我创建一个新的时Cube,我期望__make_vertices我在Cube类中定义的函数将被调用,但是我继续得到 …

我需要最简单的解决方案来转换包含多个核苷酸序列的 fasta.txt，例如

>seq1
TAGATTCTGAGTTATCTCTTGCATTAGCAGGTCATCCTGGTCAAACCGCTACTGTTCCGG
CTTTCTGATAATTGATAGCATACGCTGCGAACCCACGGAAGGGGGTCGAGGACAGTGGTG
>seq2
TCCCTCTAGAGGCTCTTTACCGTGATGCTACATCTTACAGGTATTTCTGAGGCTCTTTCA
AACAGGTGCGCGTGAACAACAACCCACGGCAAACGAGTACAGTGTGTACGCCTGAGAGTA
>seq3
GGTTCCGCTCTAAGCCTCTAACTCCCGCACAGGGAAGAGATGTCGATTAACTTGCGCCCA
TAGAGCTCTGCGCGTGCGTCGAAGGCTCTTTTCGCGATATCTGTGTGGTCTCACTTTGGT

到字典（名称，值）对象，其中名称将是>标题，值将分配给相应的序列。

您可以在下面找到我通过 2 个列表进行的失败尝试（不适用于包含 >1 行的长序列）

f = open('input2.txt', 'r')
list={}
names=[]
seq=[]
for line in f:
 if line.startswith('>'):
  names.append(line[1:-1])
 elif line.startswith('A') or line.startswith('C') or line.startswith('G') or line.startswith('T'):
  seq.append(line)

list = dict(zip(names, seq))

如果您向我提供如何修复它的解决方案以及如何通过单独的函数进行示例，我将不胜感激。

感谢帮助，

格莱布

我试图改变一个String数组的大小,但我不知道还有什么可以尝试,这个方法不起作用.这是我的代码:

import java.util.Scanner;

public class test{
    public static void main(String[] args){
        String[] names;
        names = new String[5];
        for(int i=0; i<10; ++i){
            addToArray(names, i, "blah");
        }
        System.out.println(names.length);
        System.out.println("bye");
    }

    public static void addToArray(String[] names, int i, String name){
        if (i < names.length){
            names[i] = name;
        }
        else {
            String[] temp;
            temp = new String[names.length + 10];
            System.arraycopy(names, 0, temp, 0, names.length);
            addToArray(temp, i, name);
            names = temp;
        }
    }
}

我的问题是,当我运行它时,它打印出我的数组的最终长度是5,当它应该说15.

所以我有这个联盟叫Junk.它包含一个int或char [4]数组......你可以告诉我我想要做什么.我将字母J,u,n和k的ASCII值放入我的int中,J进入第一个字节,u进入第二个字段,等等.我这样做是因为我的机器是小端,我希望包含J的字节是我的int中最左边的字节,它应该与numc [0]相对应.但我没有得到任何输出.出了什么问题？

#include <stdio.h>

union Junk {
  int num;
  char numc[4];
};

int
main(int argc, char ** argv){
  union Junk len;
  len.num = 74;         //J
  len.num &= 117 << 8;  //u
  len.num &= 110 << 16; //n
  len.num &= 107 << 24; //k
  putchar(len.numc[0]);
  putchar(len.numc[1]);
  putchar(len.numc[2]);
  putchar(len.numc[3]);
  putchar('\n');
  return 0;
}