小编Col*_*ole的帖子

我用,这是最好的作为YearQuarter想到一个自定义的数字类型,工作(即20141,20142,20143,20144,20151,20152,...),或我贴上标签,quarter_code,q_code的简称.它的递增函数类似于:

def code_sum(q_code, n):
    q_code_year, q_code_quarter = q_code // 10, q_code % 10
    n_year, n_quarter = (n // 4), (n % 4 - 1)

    quarters = q_code_quarter + n_quarter
    years = q_code_year + n_year + quarters // 4
    return years * 10 + quarters % 4 + 1

#  code_sum(20141, 1) = 20142, code_sum(20144, 1) = 20151
#  code_sum(20144, -1) = 20143, code_sum(20151, -1) = 20144
#  NOTE: code_sum(20147, 0) = 20153

我想警告或提出不符合表格的数字的例外情况year*10 + number_of_quarters …

我的第一个问题是这个问题的抽象问题是什么:'表达式返回6的操作是什么 (2 and 2*3)？请随意适当地重新调整我的问题.

我的第二个问题是python中返回6的内容是什么(2 and 2*3).这里似乎有一些优雅的东西,我想读一下这个操作.

我希望能够在模型中查询特定浮点字段没有值的记录.问题是基本查询:

 Model.objects.filter(float_field__is_null=True)

返回以下错误:django.core.exceptions.FieldError: Unsupported lookup 'is_null'.

要进行测试,请创建以下模型:

class FloatFieldModel(models.Model):
    date = models.DateField()
    val = models.FloatField(blank=True, null=True)

然后:

>>> objects = FloatFieldModel.objects.filter(val__is_null=True)
>>> django.core.exceptions.FieldError: Unsupported lookup 'is_null' ...

如何针对特定浮点字段没有值的记录过滤模型？换句话说,最好的工作是什么？

我希望能够做的是设置一个只更新没有任何值的行的例程,但跳过那些已经具有指定值的行(同时最有效地使用我的数据库).我的尝试看起来像:

for date in dates:
    try:
        FloatFieldModel.objects.filter(
            date=date,
            val__is_null=True
        ).update(val=42.0)
    except FloatFieldModel.DoesNotExist:
        pass

我想我可以这样做:

objects = FloatFieldModel.objects.all()
for obj in objects:
    if obj.val is None and obj.date in set(dates):
        obj.val = 42.0
        obj.save()

我尝试的是一个更有效的过程,而不是在保存之前需要将每个对象从数据库读入内存.

>>> from operator import itemgetter
>>> ul = [(10,2),(9,4),(10,3),(10,4),(9,1),(9,3)]
>>> ol = sorted(ul, key=itemgetter(0,1), reverse=True)
>>> ol
[(10, 4), (10, 3), (10, 2), (9, 4), (9, 3), (9, 1)]

我想要的是在第二个键上排序reverse = False.换句话说,我希望结果是:

[(10, 2), (10, 3), (10, 4), (9, 1), (9, 3), (9, 4)]

我该怎么做呢？

我有class很多方法依赖于另一个特定实例的可能但不确定的存在class.这些方法将按以下方式进行调整:if other_instance return X else return None.实际上,我写了几个相同的if语句作为每个方法的代码的一部分.(另请注意,__init__由于继承问题,我不能使用自定义.)除了None如下所示的依赖方法(在极大简化的模型上)之外,是否有一种实用或适当的方法来限制这种冗余编码？

class QuarterResult(ParentClass):
    result = None
    prior = None

    def get_prior_quarter(self):
        # code to find prior_quarter
        if prior_quarter:
            self.prior = prior_quarter
            return prior_quarter

        # commence None-ing out unusable methods
        # Note: the actual model has 10+ methods which need prior

        unusable_methods = ('change_in_results', 'quarterly_return')
        for mthd in unusable_methods:
            setattr(self, mthd, None)

    # assume this method is ALWAYS run first
    def calculate_result(self, *args): …

如果我有子列表A:['E','C','W'],根据主列表M的顺序命令子列表的最pythonic方式是什么:['C','B','W ", 'E', 'K']

我的解决方案似乎相当简陋.我很好奇是否有更'pythonic'的方法来获得相同的结果.

ORDER = ['C','B','W','E','K']
possibilities = ['E','C', 'W']
possibilities_in_order = []

for x in ORDER:
    if x in possibilities: possibilities_in_order.append(x)

>>> from operator import itemgetter
>>> l = [(1.23, 'Smith'), (2.34, 'Jones'), (3.45, 'de la Smith')]
>>> ol = sorted(l, key=itemgetter(1))
>>> ol
[(2.34, 'Jones'), (1.23, 'Smith'), (3.45, 'de la Smith')]

如何在没有使用多个列表推导的某些kludge的情况下获得以下列表？

[(3.45, 'de la Smith'), (2.34, 'Jones'), (1.23, 'Smith')]

对于n长度的数值列表,例如[1, 3, 1, 2, ...],我想创建一个列表,列出所有可能的值组合,range[x+1]其中x是列表中的值.输出可能如下所示:

for list[1, 3, 2] return all possible lists of range[x+1] values:
    # the sequence of the list is unimportant
[
[0,0,0],[1,0,0],[0,1,0],[0,2,0],[0,3,0],[0,0,1],[0,0,2],[1,1,0],
[1,2,0],[1,3,0],[1,0,1],[1,0,2],[0,1,1],[0,2,1],[0,3,1],[0,1,2],
[0,2,2],[0,3,2],[1,1,1],[1,2,1],[1,3,1],[1,1,2],[1,2,2],[1,3,2]
]

所以在这个例子中我正在寻找[e1, e2, e3]from的所有变体e1 in [0,1], e2 in [0,1,2,3] and e3 in [0,1,2]

使用以下 django 模型工作：

class Position(models.Model):
    # pos_list in order ('P', 'C', '1B', '2B', '3B', 'SS', 'LF', 'CF', 'RF')
    # pos id / pk correspond to index value of pos_list.index(pos)
    pos = models.CharField(max_length=2)

class Player(models.Model):
    name = models.CharField(max_length=100)
    positions = models.ManyToManyField(Position, through='PlayerPosition')

class PlayerPosition(models.Model):
    player = models.ForeignKey(Player)
    position = models.ForeignKey(Position)
    primary = models.BooleanField()

如果我有一个位置 id 列表，例如[3, 5]，哪里Position.objects.filter(id__in=[3,5])会产生['1B', '3B']，我希望能够Player.objects.all()通过position_id 列表[3, 5]或其他一些位置组合进行过滤。在此示例中，我想要一个包含 1B（即Position.objects.get(id=3)）或 3B（即Position.objects.get(id=5)）玩家的所有玩家的列表。我该怎么做呢？

回答：

Player.objects.filter(positions__id__in=[3,5])

第二个答案，因为__id没有必要： …

我假设try/except工作流比if/then工作流更快,因为简单的操作'尝试从list_l中删除x'.在下面的示例中,除了失败(x不在list_l中)的成本比权限请求(如果x在list_l中)的成本更高,即使异常的可能性是16.6%.为什么？

以下是我编码的测试及其结果:

import random, time, timeit

class Timer(object):
    def __enter__(self):
        self.start = time.time()
        return self

    def __exit__(self, *args):
        self.end = time.time()
        self.secs = self.end - self.start
        self.msecs = self.secs * 1000  # millisecs

def a_function():
    a_list = list(xrange(10))
    choice_list = list(xrange(12))
    choice = random.choice(choice_list)
    try:
        a_list.remove(choice)

    except ValueError:
        pass

def b_function():
    a_list = list(xrange(10))
    choice_list = list(xrange(12))
    choice = random.choice(choice_list)
    if choice in a_list:
        a_list.remove(choice)

with Timer() as a:
    print('test_a', timeit.timeit("a_function()", number=10000, setup="from __main__ import a_function"))

with Timer() as b: …