相关疑难解决方法(0)

说我有这样一个python Enum类:

from enum import Enum

class Mood(Enum):
    red = 0
    green = 1
    blue = 2

是否有一种自然的方式来获得物品的总数Mood？(像,而无需遍历它,或添加一个额外的n项,或额外的n classproperty,等等).

enum模块是否提供这样的功能？

只是看看在python中获取命名常量的方法.

class constant_list:
    (A_CONSTANT, B_CONSTANT, C_CONSTANT) = range(3)

那么当然你可以像这样引用它:

constant_list.A_CONSTANT

我想你可以使用字典,使用字符串:

constant_dic = {
    "A_CONSTANT" : 1,
    "B_CONSTANT" : 2,
    "C_CONSTANT" : 3,}

并像这样引用它:

constant_dic["A_CONSTANT"]

那么,我的问题很简单.有没有更好的方法呢？不是说这些不足或什么,只是好奇 - 我错过了任何其他常见的习语吗？

提前致谢.

我有一个Python函数,需要许多参数,其中一个参数是要执行的模拟类型.例如,选项可以是"太阳能","视图"或"两者".

什么是Pythonic方式允许用户设置这些？

我可以看到各种选择:

1. 使用字符串变量并检查它 - 所以它会 func(a, b, c, type='solar')

2. 在类中设置一些常量并使用 func(a, b, c, type=classname.SOLAR)

3. 如果只有两个选项(就像我的一些函数一样)强制它进入一个True/False参数,通过使用类似的东西func(a, b, c, do_solar=False)来使它使用'view'选项.

Pythonic做这个的任何偏好(或其他想法)？

有另一种方式只通过一个自定义类的属性没有被内置(比如迭代__dict__,__module__等等)？例如,在此代码中:

class Terrain:
    WATER = -1
    GRASS = 0
    HILL = 1
    MOUNTAIN = 2

我可以遍历所有这些属性,如下所示:

for key, value in Terrain.__dict__.items():
    print("{: <11}".format(key), " --> ", value)

哪个输出:

MOUNTAIN     -->  2
__module__   -->  __main__
WATER        -->  -1
HILL         -->  1
__dict__     -->  <attribute '__dict__' of 'Terrain' objects>
GRASS        -->  0
__weakref__  -->  <attribute '__weakref__' of 'Terrain' objects>
__doc__      -->  None

如果我只想要整数参数(枚举类型的基本版本),我可以使用:

for key, value in Terrain.__dict__.items():
    if type(value) is int: # type(value) == int …

我有一个小班,如下:

class Gender(object):
    MALE = 'M'
    FEMALE = 'F'

我有一个参数变量,只能是M或F.为了确保它只是那个,我做以下事情:

>>> parameter = 'M'
>>> if parameter not in (Gender.MALE, Gender.FEMALE)
...     print "Invalid parameter"
...
Invalid parameter
>>>

现在我有一个包含美国所有州的课程如下:

class States(object):
    ALABAMA = 'AL'
    ALASKA = 'AK'
    ARIZONA = 'AZ'
    ARKANSAS = 'AR'
    CALIFORNIA = 'CA'
    COLORADO = 'CO'
    CONNECTICUT = 'CT'
    DELAWARE = 'DE'
    DISTRICTOFCOLUMBIA = 'DC'
    ....
....

就像上面的例子一样,我的参数现在是AL.但是,由于美国有50个状态,我实际上不能使用像我上面使用的50个变量的元组.有更好的方法吗？我确实读过关于isinstance的内容,但它没有给我预期的结果.

我想执行一个进程,以秒为单位将执行时间限制为一些超时并获取进程产生的输出.我想在windows,linux和freebsd上做这个.

我试过以三种不同的方式实现它:

1. cmd - 没有超时和subprocess.PIPE用于输出捕获.

   行为:按预期运行但不支持超时,我需要超时...

2. cmd_to - 使用timeout和subprocess.PIPE进行输出捕获.

   BEHAVIOR:当输出> = 2 ^ 16字节时阻止子进程执行.

3. cmd_totf - 使用timeout和tempfile.NamedTemporaryfile进行输出捕获.

   行为:按预期运行,但在磁盘上使用临时文件.

这些可在下面获得进一步检查.

从下面的输出中可以看出,当使用子处理时,超时代码会阻止子进程的执行.PIPE和子进程的输出是> = 2 ^ 16字节.

子进程文档说明在调用process.wait()和使用subprocessing.PIPE时这是预期的,但是在使用process.poll()时没有给出警告,那么这里出了什么问题？

我在cmd_totf中有一个使用tempfile模块的解决方案,但权衡是它将输出写入磁盘,这是我真正想要避免的.

所以我的问题是:

• 我在cmd_to做错了什么？
• 有没有办法做我想要的,不使用临时文件/保持输出在内存中.

用于生成一堆输出的脚本('exp_gen.py'):

#!/usr/bin/env python
import sys
output  = "b"*int(sys.argv[1])
print output

子处理周围包装器的三种不同实现(cmd,cmd_to,cmd_totf).Popen:

#!/usr/bin/env python
import subprocess, time, tempfile
bufsize = -1

def cmd(cmdline, timeout=60):
  """
  Execute cmdline.
  Uses subprocessing and subprocess.PIPE.
  """

  p = subprocess.Popen(
    cmdline,
    bufsize = bufsize,
    shell   = False,
    stdin   = subprocess.PIPE,
    stdout  = subprocess.PIPE,
    stderr  = subprocess.PIPE
  ) …

考虑:

class Item:
   def __init__(self, a, b):
       self.a = a
       self.b = b

class Items:
    GREEN = Item('a', 'b')
    BLUE = Item('c', 'd')

有没有办法让简单枚举的想法适应这种情况？(参见这个问题)理想情况下,就像在Java中一样,我想把它全部塞进一个类中.

Java模型:

enum EnumWithAttrs {
    GREEN("a", "b"),
    BLUE("c", "d");

    EnumWithAttrs(String a, String b) {
      this.a = a;
      this.b = b;
    }

    private String a;
    private String b;

    /* accessors and other java noise */
}

我想在python中使用枚举,如下面的代码(java).我是Python的新手.我在Java中有以下代码,并希望在Python中复制功能:

class Direction {
  public enum Direction {LEFT, RIGHT, UP, DOWN}

  public void navigate(Direction direction)
    switch(direction){
        case Direction.LEFT:
            System.out.print("left");
            break;
        case Direction.RIGHT:
            System.out.print("right");
            break;
        case Direction.UP:
            System.out.print("up");
            break;
        case Direction.DOWN:
            System.out.print("down");
            break;
  }
}

如何强制用户只提供Python方法的枚举？

如何将进程的等级作为标记传递给mpi4py.MPI.COMM_WORLD.Send()函数并使用mpi4py.MPI.COMM_WORLD.Recv()正确接收它？

我指的是使用Send和Recv函数在两个进程之间发送和接收消息的以下代码示例

#passRandomDraw.py
import numpy
from mpi4py import MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()

randNum = numpy.zeros(1)

if rank == 1:
    randNum = numpy.random.random_sample(1)
    print "Process", rank, "drew the number", randNum[0]
    comm.Send(randNum, dest=0)

if rank == 0:
    print "Process", rank, "before receiving has the number", randNum[0]
    comm.Recv(randNum, source=1)
    print "Process", rank, "received the number", randNum[0]

我想将发送过程的等级作为标记传递,以便接收过程可以在有多个发件人的情况下识别它.这就是我的工作

#passRandomDraw.py
import numpy
from mpi4py import MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()

randNum = numpy.zeros(1)
rnk = -1 # EDIT …

我找到了一种简单的方法来实现(破解)枚举到Python:

class MyEnum:
  VAL1, VAL2, VAL3 = range(3)

我可以这样称呼它:

bob = MyEnum.VAL1

性感!

好吧,现在我希望能够在给定字符串时获得数值,或者如果给定数值则获得字符串.假设我希望字符串与Enum键完全匹配

我能想到的最好的是这样的:

class MyEnum:
  VAL1, VAL2, VAL3 = range(3)
  @classmethod
  def tostring(cls, val):
    if (val == cls.VAL1):
      return "VAL1"
    elif (val == cls.VAL2):
      return "VAL2"
    elif (val == cls.VAL3):
      return "VAL3"
    else:
      return None
  @classmethod
  def fromstring(cls, str):
    if (str.upper() == "VAL1"):
      return cls.VAL1
    elif (str.upper() == "VAL2"):
      return cls.VAL2
    elif (str.upper() == "VAL2"):
      return cls.VAL2
    else:
      return None

或类似的东西(忽略我如何捕捉无效案件)

有没有更好的,更蟒蛇为中心的方式去做我上面做的事情？或者以上内容已经尽可能简洁.

似乎必须有一个更好的方法来做到这一点.