BrokenBenchmark

你的 for 循环在第一个匹配的值处停止。它不会为您的值找到所有匹配项。

没有必要创建单独的词典。可以根据值按降序对字典中的项进行排序,然后迭代排序过程的结果。

costumer_dict = {3:30, 1:22, 2:22}

for key, value in sorted(costumer_dict.items(), key=lambda x: x[1], reverse=True):
    print(f"{key},{value}")

这将产生:

3,30
1,22
2,22

可以使用辅助列表跟踪自上次浮点值以来看到的数组元素。每当看到浮点时,将现有元素转换为元组并清除辅助列表:

result = []
items = []

for item in arr:
    if isinstance(item, float) and items:
        if len(items) < 3:
            items.append(None)
        result.append(tuple(items))
        items = [item]
    else:
        items.append(item)
    
result.append(tuple(items))

print(result)

这将产生:

[
 (1150.1, 'James', None), (3323.1, 'Steve', None),
 (9323.1, 'John', None), (1233.1, 'Gary', 'criminal'),
 (3293.1, 'Josh', None), (9232.1, 'Daniel', 'criminal')
]

你可以用 itertools.islice() 跳过第一个元素,然后使用 zip() 要将每个列表值与要附加的列表配对,请执行以下操作:

from itertools import islice
for lst_value, lst_to_append in zip(islice(d2.values(), 1, None), list_of_lists):
    lst_value.append(lst_to_append)
    
print(d2)

这将产生:

{
 'Youngstown': ['OH', 4110, 8065, 115436],
 'Yankton': ['SD', 4288, 9739, 12011, [966]],
 'Yakima': ['WA', 4660, 12051, 49826, [1513, 2410]]
}

可以将数组索引与 np.ndarray.flatten :

print(a[:,:,0].flatten())
print(a[:,:,1].flatten())

这将产生:

[0.08467145 0.08470057 0.0846846  0.08469571]
[0.0846905  0.08483638 0.08471105 0.08472978]

您可以索引到列表和字典中——使用 [0] ,并使用 ['translation_text'] :

translated = pipe(reviews['review'][0])[0]['translation_text']

在第一次运行内部循环时 i = 0 这个 for 循环根本不执行。(在中有零个元素需要迭代。) range(0) ).

在第二次运行内部循环时 i = 1 这个 对于 循环执行一次迭代。(其中有一个元素需要迭代。) range(1) ).

然后,第三轮有两个元素,第四轮有三个元素,遵循这个模式,直到 i = n - 1 .

迭代的总数为 0 + 1 + ... + (n - 1) 这个总和有一个众所周知的形式:对于任何自然 m , 0 + 1 + ... + m = m * (m + 1) / 2 .在这种情况下,我们有 m = n - 1 ,所以有 n * (n - 1) / 2 总迭代次数。

你是对的,这个算法的渐近时间复杂度是 O(n^2) .然而,考虑到你说的“正确答案”是 n*(n-1)/2 ,问题很可能是询问迭代的确切次数(而不是渐近界)。

一个快速的解决方法是使用 subprocess.call() :

import subprocess

filepaths = ["C:\\Users\\harsh\\My Drive\\Folder\\Code\\3.py",
    "C:\\Users\\harsh\\My Drive\\Folder\\Code\\4.py",
    "C:\\Users\\harsh\\My Drive\\Folder\\Code\\5.py",
    "C:\\Users\\harsh\\My Drive\\Folder\\Code\\Helper codes\\6.py",
    "C:\\Users\\harsh\\My Drive\\Folder\\Code\\Process\\7.py"
]

for filepath in filepaths:
    subprocess.call(["python", filepath])

但是,如果每个脚本的主要方法是这样布置的,则也可以使用导入:

def main():
   ...

if __name__ == '__main__':
   main()

然后,您的脚本可以如下所示:

import module1
import module2
... # more imports

module1.main()
module2.main()
... # more main methods

按顺序运行主要方法。这更可取(更简洁,不需要产生新的流程),但可能需要一些重构。

此函数假定输入的长度至少为2,但可以使用字符串索引来获取第一个和最后一个字符,然后在两者之间添加适当数量的星号:

def replace_characters(s):
    return s[0] + '*' * (len(s) - 2) + s[-1]

print(replace_characters('apples')) # 'a****s'
print(replace_characters('car')) # 'c*r'

你可以用 .rstrip() :

data = ['FSDAF\n', 'HKLWF\n', 'AAKEP\n']
print([line.rstrip() for line in data])

可以将关键参数传递给 .sort() .

在当前代码下面,添加:

ratio.sort(key=lambda x: x[1])

按比率排序(与默认排序机制相反,默认排序机制从列表中的第一个元素开始)。

在这次分拣操作之后, ratio 将:

[[2, 0.5], [3, 0.6666666666666666], [5, 1.2], [4, 1.25]]

你可以用 zip() 使用解包操作符获取子列表中每个位置的选项,然后使用列表理解对原始列表中的每个元组执行此操作。值得注意的是,如果每个元组中的列表数量可变,则解包的使用使此操作可扩展:

import random
[[random.choice(choices) for choices in zip(*item)] for item in value]

根据给定的数据,您将得到如下输出:

[['55', '60', '61', '62', '2'], ['51', '52', '65', '66', '2']]

这里有两种简洁的方法。

第一次使用 itertools.product() 还有一份清单:

from itertools import product

[x * y for x, y in product(list1, list2)]

但是,这个问题非常适合于 itertools.starmap() ,这是第二种方法的动力。如果您不熟悉该函数,它会包含两个参数:

• 接受两个参数的函数。在这种情况下,我们使用 operator.mul ,一种我们可以传递到函数中的乘法运算符。请注意,函数可以传递到Python中的其他函数中,因为函数是 first class .
• 一个二号的小房间。在这种情况下,这是我们从 itertools。产品() .

对于iterable中的每个元素,它将元素解包,并将每个元素作为参数传递到第一个参数指定的函数中。这给了我们:

from itertools import product, starmap
import operator

list(starmap(operator.mul, product(list1, list2)))

这两种输出:

[12, 4, 36, 8, 6, 2, 18, 4, 21, 7, 63, 14]

如果您想将此方法扩展到两个以上的iTerable,可以这样做(如 flakes ):

from math import prod
list(map(prod, product(list1, list2, <specify more iterables>)))

其他答案建议使用多个选项 for 理解中的循环。注意 some consider this approach to be poor style ; 使用 itertools。产品() 完全避免这个问题。

_{如果你有任何问题,请随意评论——我非常乐意澄清任何困惑。我意识到这些解决方案可能不是最适合初学者的。至少,我希望这些方法对未来的读者有用。}

我会把它变成一个 for 循环,跟踪到目前为止看到的元素的总和,如果不等式适用于该迭代,则调整相应的元素:

for num2, row2 in enumerate(grid):
    total = 0
    for n_idx, n_elem in enumerate(n):
        if total <= num2 < total + n_elem:
            grid[num2][n_idx + 1] = c[num2]
        total += n_elem

我建议不要使用 sum() 在这个循环中,它在每次迭代时从头开始重新计算总和,这不是很有效。

你可以使用 ast 模块:

import ast

data = "log(2, floor(9.4))"
parse_tree = ast.parse(data)

# ast.unparse() is for 3.9+ only.
# If using an earlier version, use the astunparse package instead.
result = [ast.unparse(node) for node in parse_tree.body[0].value.args]
print(result)

这将产生:

['2', 'floor(9.4)']

我从手动检查 ast.dump(parse_tree) .

注意,我写的东西有点快,有点脏,因为只有一个字符串需要解析。如果你想解析很多这样的字符串(或者一个更大的程序),你应该创建 ast.NodeVisitor .如果你还想修改源代码,你应该创建 ast.NodeTransformer 相反

使用列表理解:

data = [x for x in data if x.num > 5]

请注意,您需要执行以下操作: 一些 对数据进行迭代排序,以确定是保留还是删除结果中的元素。(即使迭代结构不是显式的,无论你使用什么,都可能会在幕后使用迭代。)一般来说,在迭代列表时修改列表是个坏主意。

你的支票使用位移位, 不 比较操作。它总是会产生一个 falsey 价值

<< 是吗 left shift operator 是的 不 比较操作(使用 < 或 <= 如果你想要比较)。

为了了解这个表达式是如何工作的,我们从左到右计算运算。所以 0 << a << 10 相当于 (0 << a) << 10 .

• (0 << a) 0移位了吗 a 位,也就是0。 A. 这里正好是7,但将0移位任意位数仍然会产生0。
• 0 << 10 在10位上移位0,这仍然是0。
• 零是一个错误的值,所以 if 检查失败,并且 else 分支被执行。

使用 itertools.product() 和 repeat 参数使用 itertools.combinations() 不允许多次选择同一个字母:

import string as s
import itertools as it

things = s.ascii_letters

for digits in range(2, 6):
    for combo in it.product(things, repeat=digits):
        output = ''.join(combo)
        print(output)

你可以用 map() 生成一个包含 numbers 增加2。自从 地图() 创建一个新的iterable,但不修改原始列表:

numbers = [3, 4, 6, 7]

for x in map(lambda x: x + 2, numbers):
    a = 5 - x
    b = 5 + x
    c = 5 * x
    print(x, a, b, c)

这将产生:

5 0 10 25
6 -1 11 30
8 -3 13 40
9 -4 14 45

你可以测量 foo() 用两个电话 time.time() 。然后,您可以使用计算的执行时间来计算暂停程序执行的时间量 foo() :

import time

def foo():
    ...

start_time = time.time()
foo()
end_time = time.time()
if end_time - start_time < 10:
    time.sleep(10 - (end_time - start_time))

注意,我们使用 time.sleep() 而不是 while 循环,反复检查是否经过了足够的时间 busy waiting wastes resources .

您需要将递归调用的结果返回给 binary_search_recursive() :

binary_search_recursive(array, left + 1, right, key)

应该是

return binary_search_recursive(array, left + 1, right, key)

请注意,这是 不 二进制搜索算法;一次只枚举一个元素(使用递归),所以这实际上是一个顺序搜索。

唯一的问题是你的位置 print() 陈述它应该在外面 for 循环,你应该打印 entry['services'] 而不是 i 。这允许您一次打印所有更新的条目,而不是一次打印一条。

y = {"pin":110096}
entry = json.loads(json_var)

for i in entry['services']:
    i.update(y)

print(json.dumps(entry['services']))

这将产生:

[{"service_name": "stack1", "service_version": "1", "pin": 110096},
{"service_name": "stack2", "service_version": "2", "pin": 110096},
{"service_name": "stack3", "service_version": "3", "pin": 110096}]

你可以添加一个 print() 内部声明 RollDice() 功能(尽管这会导致生成器产生打印到控制台的副作用,这可能是可取的,也可能不是可取的,取决于您是否在其他地方使用此功能):

def Rolldice(s,r):
    for i in range(0,r):
        die = random.randint(1, s)
        print(f"Die {i}: {die}")
        yield die

LeetCode允许您使用Python列表表示法指定链表,以便在浏览器中执行测试。这是 不 链表在内存中的实际表示方式;LeetCode在后端运行代码,将您输入的列表作为测试用例,并将其转换为链接列表。

如果您试图在本地测试代码,并希望表示一个空的链表,请使用 None 而不是 [] .具有一个节点的链表可以声明如下:

singleton_linked_list = ListNode(5) # Creates a new linked list with one node.

可以使用元组和元组解包(请参见 this Python文档中的部分):

p = (1, 2)
a, b = p
print(a, b) # Prints 1 2

你可以用 .extend() 将递归调用的结果连接到列表。

def recursive_lookup(data, key):
    values = []
    if isinstance(data, list):
        for i in data:
            values.extend(recursive_lookup(i, key))
    elif isinstance(data, dict):
        for i, v in data.items():
            if i == key:
                values.append(v)
            if isinstance(v, list) or isinstance(v, dict):
                values.extend(recursive_lookup(v, key))
    return values

两种方法:

1. 使用 map() 和 ''.join :

data = [[['a', 'b'], ['b', 'a'], ['c', 'c']], [['d', 'e'], ['e', 'd']]]
result = [list(map(''.join, item)) for item in data]
print(result)

2. 使用列表理解:

data = [[['a', 'b'], ['b', 'a'], ['c', 'c']], [['d', 'e'], ['e', 'd']]]
result = [[''.join(item) for item in sublist] for sublist in data]
print(result)

这两种印刷品:

[['ab', 'ba', 'cc'], ['de', 'ed']]