Thierry Lathuille

可以使用默认值 None

class Queue:
  def __init__(self, max_size=None):
    self._qhead = None
    self._qtail = None
    self._count = 0
    self.max_size = max_size

在相关方法中:

if max_size is None:
    # code for the unbounded case
else:
    # we have a value for max_size, act accordingly

分类是 guaranteed to be stable ,这意味着如果某些项具有相同的键值,则保留其原始顺序。

更容易看到字符串发生了什么,而且没有相反的顺序:

list(sorted(['zzz', 'aa', 'cc', 'bb', 'bbb', 'aaa'], key=len))
# ['aa', 'cc', 'bb', 'zzz', 'bbb', 'aaa']

所有长度为2的字符串首先按其原始顺序排列,然后所有长度为3的字符串也按其原始顺序排列。

在代码中,计数为2的值依次为3、11、11和3。所以,在排序之后,它们将保持这个顺序(颠倒过来,正如您所要求的那样,但看起来是一样的)。

如果要按计数,然后按值(而不是按原始顺序)排序,则必须使其显式,其中:

def frequency_sorting(numbers):
    return sorted(numbers, key=lambda i:(numbers.count(i), -i), reverse=True)

使用 sets 因此,这是有效测试交叉口的唯一方法。:

confirmed = [(60, 176), (60, 174), (63, 163), (61, 176)]
white = [(64, 178), (60, 174), (61, 176)]

要到达十字路口:

print(set(confirmed).intersection(white))
# {(60, 174), (61, 176)}

得到 True 或 False ,只需将结果集转换为 bool :空集为False,非空集为True:

print(bool(set(confirmed).intersection(white)))
# True

另一个例子,有空交集:

confirmed = [(60, 176), (600, 174), (63, 163), (6100, 176)]
white = [(64, 178), (60, 174), (61, 176)]


print(set(confirmed).intersection(white))
# set()
print(bool(set(confirmed).intersection(white)))
# False

你本可以用的 set([(1, 2)]) 为了达到同样的目的。

函数调用有一组括号(不,不是双关语…)。 set() 接受一个iterable作为参数,这个列表只包含您的元组。

如果你想使用元组而不是列表,它会变得更难阅读。与列表等价的元组 [item] 是元组吗 (item,) -逗号使它成为元组,而不是括号。

所以,替换我的 [ (1, 2) ] 具有 ( (1, 2), ) ,你得到你的 set(((1, 2),))

当然,正如评论中指出的, {(1, 2)} 这是最简单的写法…

你可以 join 不是 None 以下内容:

keys = ["[zipcode]", "[street_name]", "[primary_number]",
        "[secondary_number]", "[street_predirection]", "[street_postdirection]",
        "[street_suffix]"]

d['AddressStr'] = ' '.join([d[key] for key in keys if d[key] is not None])

可以使用双引号在非引号中使用该部分。 .+? :

import re

s = """c2+"hello""+"c4"""
x = re.split("(\".+?\"|\+)",s)
print(x)
# ['c2', '+', '', '"hello"', '', '"+"', 'c4']

注意,与预期的输出有一个区别:“hello”和“+”之间的空字符串。这是故意的,以便分隔符始终出现在结果列表中的奇数索引处(字符串的其他部分出现在偶数索引处)。

你可以让他们用 itertools :

from itertools import permutations, product

a_variants = [dict(zip(["ad", "bigd", "lugd"], values)) 
                 for values in product(permutations(["tau","guru"]), repeat=3)]
b_variants = [dict(zip(["tau", "guru"], values)) 
                 for values in product(permutations(["ad", "bigd", "lugd"]), repeat=2)]

all_variants = product(a_variants, b_variants)

for va, vb in all_variants:
    print("a:", va, "\nb:", vb, "\n")

输出:

a: {'ad': ('tau', 'guru'), 'bigd': ('tau', 'guru'), 'lugd': ('tau', 'guru')} 
b: {'tau': ('ad', 'bigd', 'lugd'), 'guru': ('ad', 'bigd', 'lugd')} 

a: {'ad': ('tau', 'guru'), 'bigd': ('tau', 'guru'), 'lugd': ('tau', 'guru')} 
b: {'tau': ('ad', 'bigd', 'lugd'), 'guru': ('ad', 'lugd', 'bigd')} 

...

a: {'ad': ('guru', 'tau'), 'bigd': ('guru', 'tau'), 'lugd': ('guru', 'tau')} 
b: {'tau': ('lugd', 'bigd', 'ad'), 'guru': ('lugd', 'ad', 'bigd')} 

a: {'ad': ('guru', 'tau'), 'bigd': ('guru', 'tau'), 'lugd': ('guru', 'tau')} 
b: {'tau': ('lugd', 'bigd', 'ad'), 'guru': ('lugd', 'bigd', 'ad')} 

注意,您有2**3*(3*2)**2=288个不同的输出。

使用 groupby ,您可以:

from itertools import groupby

a= [0,0,0,1,1,1,3,3,3]
b= ['a','b','c','d','e','f','g','h','i']

iter_b = iter(b)
output = [[next(iter_b) for _ in group] for key, group in groupby(a)]

print(output)
# [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]

子句 产生具有相同值的连续组 a . 对于每个组,我们创建一个列表,其中包含 b 因为组中有值。