Глеб's questions

LeetCode有一个任务。条件是给你一个 intnums和 int的列表target，并且你需要返回两个数字相加的索引target。我写了下面的算法来解决这个问题：

def twoSum(self, nums: List[int], target: int) -> List[int]:
    if all(i <= 0 for i in nums): 
        nums = [abs(i) for i in nums]
        target = abs(target)
    for i in range(min(nums) - 1, target + 1):
        j = target - i
        if i != j:
            if i in nums and j in nums:
                return [nums.index(i), nums.index(j)]
        else:
            if nums.count(i) > 1:
                return [n for n, m in enumerate(nums) if m == i][:2]

他通过了基本测试，但未能通过大量测试 - 时间不够。如何对其进行优化？

假设我们有某种列表：

>>> l = [1, 2, 3, [4, [5], [6, 7]]]

我们需要找出它的各项之和。一切都清楚了，正常的递归：

>>> def list_sum(l):
        r = 0
        for i in l:
            if type(i) == int:
                r += i
            elif type(i) == list:
                r += list_sum(i)
        return r

>>> list_sum(l)
28

现在我们将对列表做一些事情。

>>> l.append(l)
>>> l
[1, 2, 3, [4, [5], [6, 7]], [...]]

这称为“循环”列表。让我们再次尝试计算项之和。而且当然...

>> list_sum(l)
    Traceback (most recent call last):
      File "<pyshell#22>", line 1, in <module>
        list_sum(l)
      File "<pyshell#17>", line 7, in list_sum
        r += list_sum(i)
      File "<pyshell#17>", line 7, in list_sum
        r += list_sum(i)
      File "<pyshell#17>", line 7, in list_sum
        r += list_sum(i)
      [Previous line repeated 1022 more times]
      File "<pyshell#17>", line 4, in list_sum
        if type(i) == int:
    RecursionError: maximum recursion depth exceeded in comparison

那么，该如何处理呢？

>>> def new_sum(l):
        r = 0
        for i in l:
            if type(i) == int:
                r += i
            elif type(i) == list:
                if i is l:
                    pass
                else:
                    r += new_sum(i)
        return r

>>> new_sum(l)
28

让我们更加混淆这个列表：

>>> l[3].append(l)
>>> l
[1, 2, 3, [4, [5], [6, 7], [...]], [...]]

...并且不再有效：

>>> new_sum(l)
    Traceback (most recent call last):
      File "<pyshell#40>", line 1, in <module>
        new_sum(l)
      File "<pyshell#36>", line 10, in new_sum
        r += new_sum(i)
      File "<pyshell#36>", line 10, in new_sum
        r += new_sum(i)
      File "<pyshell#36>", line 10, in new_sum
        r += new_sum(i)
      [Previous line repeated 1022 more times]
      File "<pyshell#36>", line 4, in new_sum
        if type(i) == int:
    RecursionError: maximum recursion depth exceeded in comparison
    

问题：是否可以实时解析这样的结构？我当然可以编写一个详尽的搜索函数，不会让递归进入循环，但算法的复杂度显然会增加几个数量级。是否有算法可以加快“通过”此类列表的速度？

PS 不，这是一个纯粹的理论任务。如果我尝试不在 Python 中而是在 Explorer 中实现这一点，那么 Windows 会很快告诉我它对我的所有想法。所以这个任务没有真正的类似物。我只是无事可做）

我正在尝试使用 numpy function 将数组（字符串列表）旋转 90 度np.rot90。

list = ['123', '456', '789']
list = np.rot90(list)

发生错误

ValueError: Axes must be different.

为什么会发生这种情况？

• 什么是命名元组？
• 如何使用它们？
• 我应该在哪里使用命名元组而不是常规元组？

_{^{PS这是enSO问题的翻译。对“为什么要做这样的翻译”主题感兴趣的人请点击这里}}。

有没有办法获取所有Python内置函数的名称列表？

类型：

lst = [abs, all, any, ascii ... super, tuple, type, zip]

不是字符串，而是函数的链接，以便无需 eval() 即可调用它们。

切片语法在 Python 中如何工作？也就是说，当我写这样的代码时

a[x:y:z], a[:], a[::2] 

等等，我如何了解哪些元素属于切片？

PS这是enSO问题的翻译。

_{^{对“为什么要做这样的翻译”主题感兴趣的人请点击这里}}。

有一个特定的日期，格式为“年日月”，例如：

date = "2008 02 08"

您需要检查它是否有效。例子：

"2021 25 12"      ->   Правильная дата 
"2000 01 01"     ->   Правильная дата
"1975 21 01 1"    ->   Неправильная дата (неправильный формат)
"2011 34 06"      ->   Неправильная дата (34 июня не существует)
"2019 29 02"      ->   Неправильная дата (в високосном годе нет 29 февраля)

当然，您可以使用一堆if-s 进行检查，构建一个复杂的常规序列 - 是的，但我想以某种方式更简单地做到这一点。

是否有任何函数（来自内置库或第三方）可以检查日期有效性？

假设我得到一个列表，需要从中删除给定的元素：

lst = ['cat', 'dog', 'pig', 'bird', 'bear']

def func(lst, what_to_remove):
    pass

我希望该函数是一行，我正在尝试这样做：

lst = ['cat', 'dog', 'pig', 'bird', 'bear']

def func(lst, what_to_remove):
    return lst.remove(what_to_remove)

print(func(lst, 'bird'))

当然，没有任何作用（因为remove()它没有返回任何内容）：

是否可以从列表中删除一个元素并在一行中返回该列表？

有一些国外的GitHub仓库。我需要在那里添加几个文件，但是当我创建它们并将它们发送以供审核时，它们会形成一个拉取请求。怎么做？

PS我是 GitHub 的新手，所以请尽可能详细地解释所有内容。如果信息不够，请告诉我，我会提供。

我应该使用什么命令pip来一次更新所有软件包？到底有这样的团队吗？如果是这样，这取决于您使用的操作系统吗？

附言。没有必要默默地给我一些其他网站的链接。我自己知道如何使用谷歌。我需要对所提出的问题有一个明确的答案。

任务是返回一个字符串在另一个字符串中出现的次数。问题很简单，我打算用函数来解决count()。一切似乎都很顺利：

>>> 'abcdefabc'.count('abc')
2
>>> 'aaa'.count('a')
3
>>> 'abca'.count('a')
2

然后突然：

>>> 'catcatcat'.count('catcat')
1

理论上，count()它应该返回字符串中子字符串出现的次数。事实证明，它返回不相交出现的次数。

问题：如果您需要返回出现的总数以及交集，该怎么办？也就是说，最后一个例子返回2?

任务：

给出一个整数。编写一个返回数字数字乘积的函数。

例子：

multiply(1)     => 1
multiply(123)   => 6
multiply(1024)  => 0
multiply(1111)  => 1

我的决定：

def multiply(n):
    c = 1
    for i in str(n):
        c *= int(i)
    return c

我想知道其他解决方案。即：

• 一行（无法弄清楚如何做到这一点）
• 有趣（使用 dunder 方法）
• 使困惑

有一些带有错误处理程序的代码：

def return_exception():
    try:
        x = 1 / 0
        # Здесь происходит некая ошибка
    except:
        exception_name = # ???
        return exception_name

如何获取块中发生的异常的名称except？在上面的示例中，它应该返回ZeroDivisionError.

有一段代码：

x = 1

def A():
    global x
    print(x + 1)
    def B():
        nonlocal x
        print(x + 2)
    B()
A()

def C():
    global x
    return x + 1

给出以下错误：

  File "main.py", line 6
    nonlocal x
    ^
SyntaxError: no binding for nonlocal 'x' found

问题： 是什么原因导致此错误以及如何修复它？

PS给出的“程序”是一个大大简化的真实代码。我提前警告你：该程序需要这样的架构，而且正是这样的架构。事实是，变量x可能很大（1+ MB），并且函数可以被调用数百万次，因此在调用函数时B()不能传递它- 程序会严重冻结。xB()

通常，当我需要打开一个文件并读取其中的所有行时，我会编写如下内容：

f = open('data.txt')
data = f.readlines()

然而，有一个建议说最好使用上下文管理器来做到这一点：

with open('data.txt') as f:
    data = f.readlines()

问题：这两个片段有何不同？为什么第二个比第一个更好？

健康）状况

n您需要编写一个函数来生成括号对的“平衡”组合的完整列表。平衡组合是指每个左括号必须有一个对应的右括号，并且右括号不能出现在对应的左括号之前。

输入数据：

输入是 0 到 15 之间的正整数（实际上是n）（类型int）。

输出

输出应该是平衡括号字符串的完整列表（类型list）（参见示例）。

例子：

0 => [""]

1 => ["()"]

2 => ["()()","(())"]

3 => ["()()()","(())()","()(())","(()())","((()))"]

评价标准：

竞赛语言为Python 3。

最快的解决方案将赢得竞争。

来源：

来源是Codewars All Balanced Parentheses 4 kyu 难度的问题。

聚苯乙烯

如果我以某种方式错误地设置了竞赛格式，我将很乐意接受更正和澄清。

UPD： 以下代码用于打发时间：

import time

def count_time(function, f_arg, how_many_times):
    a = time.time()
    for i in range(how_many_times):
        function(f_arg)
    b = (time.time() - a) / how_many_times
    return b

结果：

• 第一个解决方案@MBo：26.08478112220764

• 第二个解决方案@MBo：（我相信它，我没有检查它，我们假设它是 10,000 秒。）

• 第一个解决方案@StanislavVolodarskiy：（在第六次迭代时，计算机冻结并且算法未完成）

• 第二个解决方案@StanislavVolodarskiy：4.338251447677612

总的来说，根据 StanislavVolodarskiy 性质的迭代构建获胜！我接受他的回答。

有一条特定的线：

s = ['This, is? a! string.']

我需要用空格替换这一行中的所有标点符号。当然你可以这样做：

s = s.replace('.', ' ')
s = s.replace(',', ' ')
s = s.replace('!', ' ')
s = s.replace('?', ' ')

但肯定有更短的方法来做到这一点吗？

PS我还希望看到使用标准模块的优雅解决方案（例如，通过正则表达式）。

我正在尝试使用 Python 解释器，并发现了以下有趣的行为：

>>> (...)
Ellipsis
>>> [...]
[Ellipsis]
>>> {...}
{Ellipsis}
>>> type((...))
<class 'ellipsis'>
>>> type([...])
<class 'list'>
>>> type({...})
<class 'set'>
>>> type(...)
<class 'ellipsis'>

循环列表时会发生类似的行为：

>>> x.append(x)
>>> x[0]
[[...]]

尽管这显然不完全正确。

有谁知道这个神秘的省略号是什么以及它的用途是什么？

在许多编程语言（例如，C、C++、PHP、Perl、Pascal、Basic）中都有一个无条件跳转运算符 - goto。Python 没有它，因为它被（正确地）认为会破坏代码的逻辑。

我有一个问题：是否可以在Python中模拟这个运算符？建议这样做，以便命令将执行直接转换为指定的行号/标签，即，使其与其他语言中的原始命令完全相同。

我的尝试没有成功。我尝试使用它exec，但完全困惑了。

PS这个问题是在将汇编代码翻译成 Python 时出现的。有时，汇编程序的编写水平非常高，以至于在物理上无法理解它们。如果你试图通过将其分解为一些函数或块来进行翻译，那么存在中断程序运行的很大风险。我必须逐字重写。

PPS我不知道是否有必要说模拟器应该尽快运行，因为程序是汇编程序，并且是为快速执行而设计的。

在 Python 中，有两种方法可以将函数应用于可迭代对象的每个元素：

1. 功能map()：

>>> lst = [1, 2, 3, 4]
>>> list(map(str, lst))
['1', '2', '3', '4']
>>> list(map(lambda a: a + 1, lst))
[2, 3, 4, 5]

2. 列表包含：

>>> lst = [1, 2, 3, 4]
>>> [str(i) for i in lst]
['1', '2', '3', '4']
>>> [i + 1 for i in lst]
[2, 3, 4, 5]

《Python 之禅》中有这样一句话：

应该有一种——最好只有一种——明显的方法来做到这一点。

应该有一种，最好只有一种，明显的方法来做到这一点。

由于有两种方法可以将函数应用于可迭代对象，因此 Python 的创建者有充分的理由引入它们。

问题出现了：哪些？在上面的示例中，这两种方法看起来都很自然。显然，存在仅使用这些方法中的一种更容易的问题。那么什么时候最好使用map()以及什么时候最好将其包含在列表中呢？