Сергей's questions

基本信息：

问题：出于教育目的，我决定在嵌套查询中使用日期。我得到了一个奇怪的结果——一个单独的带有 DATE 的嵌套查询（一个带有 DATETIME 的字段）可以正常工作。但作为子查询，它会引发错误。她在我看来是不可理解的。同时，如果您在此子查询中仅使用带有 DATETIME 的字段，则不会出错。尊重 DATE 的文档 - 仍然不清楚。请告知是什么问题，如何处理，在更广泛的层面上是否存在类似问题？我在 Stepic 平台上运行，也许他们有问题？

代码的作用：如果具有特定卡的用户在同一天从不同城市呼叫，则请求发出所有这些呼叫（针对所有此类用户）。

错误代码：

SELECT id, User, card, DATE(calling_Time) AS Calling_DATE, City 
FROM calls
WHERE (User, card, DATE(calling_Time)) IN ((
    SELECT User, card, DATE(calling_Time)  
    FROM calls
    GROUP BY User, card, DATE(calling_Time)
    HAVING COUNT(City) > 1));

错误文本： 错误 1055：HAVING 子句的表达式 #1 不在 GROUP BY 子句中，并且包含在功能上不依赖于 GROUP BY 子句中的列的非聚合列“calls.calling_Time”；这与 sql_mode=only_full_group_by 不兼容

附加信息

工作内部查询+结果：

SELECT User, card, DATE(calling_Time)  
    FROM calls
    GROUP BY User, card, DATE(calling_Time)
    HAVING COUNT(City) > 1;

+------+------+--------------------+
| User | card | DATE(calling_Time) |
+------+------+--------------------+
| 1    | 1    | 2018-05-25         |
+------+------+--------------------+
Affected rows: 1

工作完整代码（仅没有 DATE）+ 结果：

SELECT id, User, card, calling_Time, City 
FROM calls
WHERE (User, card, calling_Time) IN ((SELECT User, card, calling_Time  
    FROM calls
    GROUP BY User, card, calling_Time
    HAVING COUNT(City) > 1));

+----+------+------+---------------------+--------+
| id | User | card | calling_Time        | City   |
+----+------+------+---------------------+--------+
| 1  | 1    | 1    | 2018-05-25 21:25:54 | Москва |
| 4  | 1    | 1    | 2018-05-25 21:25:54 | Питер  |
+----+------+------+---------------------+--------+
Affected rows: 2

创建并填充测试表：

CREATE TABLE calls(
    id INT PRIMARY KEY AUTO_INCREMENT,
    user VARCHAR (25),
    card INT,
    calling_Time DATETIME,
    City VARCHAR (25)
);
INSERT INTO calls (user, card, calling_Time, City)
    VALUES
    (1, 1, '2018-05-25 21:25:54', 'Москва'),
    (2, 1, '2018-05-25 21:25:54', 'Самара'),
    (1, 1, '2018-05-26 21:25:54', 'Москва'),
    (1, 1, '2018-05-25 21:25:54', 'Питер')
;
SELECT * FROM calls;

+----+------+------+---------------------+--------+
| id | user | card | calling_Time        | City   |
+----+------+------+---------------------+--------+
| 1  | 1    | 1    | 2018-05-25 21:25:54 | Москва |
| 2  | 2    | 1    | 2018-05-25 21:25:54 | Самара |
| 3  | 1    | 1    | 2018-05-26 21:25:54 | Москва |
| 4  | 1    | 1    | 2018-05-25 21:25:54 | Питер  |
+----+------+------+---------------------+--------+
Affected rows: 4

在执行复杂的学习任务时（例如，在算法或数据结构上），许多人（包括我在内）由于使用递归而周期性地遇到问题。超出了允许的堆栈大小，或者程序运行的时间超过了条件允许的时间。在实际工作中，这将意味着程序运行缓慢或计算机资源使用效率低下。

同时，通过搜索找到避免此类问题的简单方法也不是很容易，文章更多是复杂的案例，你必须想出，在没有技巧的情况下，这可能不会很快。这里建议放一小部分简单的方法（最好是读者自己以答案的形式添加）。更好地关注 Python，但原则上大多数应该在逻辑上适用于许多编程语言。我想社区应该从知识库中受益。

我正在研究张开树，我决定使用一篇带有正面评价的文章以及来自 habr 的分析和代码：https ://habr.com/ru/company/JetBrains-education/blog/210296/

在文章中，顶点是由一个类来描述的，并没有对代码如何处理多个顶点进行注释。可能是我的实践知识不足以理解创建类元素的过程（我学过OOP，但没有在实践中使用，函数式的方法就够了）。

因此，为了让代码正常工作，我引入了一个列表li，其中我将类实例一个一个放置（一个实例 - 一个顶点），整个树的重建只是通过更改指向孩子和父母的指针，我不对列表进行排序本身。当然，我不得不重写列表下的整个代码（我的部分代码如下）。

问题：我做了正确的事情吗，或者代码可以不改变，但是对于顶点，有必要做一些不同的事情——更多的 OOP 或更高效？

文章中的示例代码（带引号），文章中的所有代码都按照评论中的要求在下面给出：

“要描述树的结构，我们需要一个描述单个顶点的简单类，”

class Node:
  def __init__(self, key, left = None, right = None, parent = None):
    self.left   = left
    self.right  = right
    self.parent = parent
    self.key    = key

“以及两个用于处理指向父母的指针的辅助程序。”

def set_parent(child, parent):
  if child != None:
    child.parent = parent

def keep_parent(v):
  set_parent(v.left, v)
  set_parent(v.right, v)

和插入过程：

def insert(root, key):
  left, right = split(root, key)
  root = Node(key, left, right)
  keep_parent(root)
  return root

我对应的一段代码带了一个列表（类我就不重复了，描述方式和文章一样，我不引用函数调用来减少题量）：

def set_parent(child, parent):
    if child != None:
        # Изменение относительно исходного кода
        li[child].parent = parent  

def keep_parent(v):
    # Изменения относительно исходного кода 
    set_parent(li[v].left, v)  
    set_parent(li[v].right, v) 

def insert(root, key):
    left, right = split(root, key)
    # Изменение относительно исходного кода 
    li[root] = Node(key, left, right)
    keep_parent(root)
    return root

# Объявление списка
li = []
n = input()
for _ in range (n): 
    number = input () 
    # Добавление в список вершины
    li.append(Node(number)) 

来自文章https://habr.com/ru/company/JetBrains-education/blog/210296/的完整代码：

class Node:
  def __init__(self, key, left = None, right = None, parent = None):
    self.left   = left
    self.right  = right
    self.parent = parent
    self.key    = key

def set_parent(child, parent):
  if child != None:
    child.parent = parent

def keep_parent(v):
  set_parent(v.left, v)
  set_parent(v.right, v)

def rotate(parent, child):
  gparent = parent.parent
  if gparent != None:
    if gparent.left == parent:
      gparent.left = child
    else:
      gparent.right = child

  if parent.left == child:
    parent.left, child.right = child.right, parent
  else:
    parent.right, child.left = child.left, parent

  keep_parent(child)
  keep_parent(parent)
  child.parent = gparent

def splay(v):
  if v.parent == None:
    return v
  parent = v.parent
  gparent = parent.parent
  if gparent == None:
    rotate(parent, v) 
    return v    
  else:
    zigzig = (gparent.left == parent) == (parent.left == v)
    if zigzig:
      rotate(gparent, parent)
      rotate(parent, v)
    else:
      rotate(parent, v)
      rotate(gparent, v)
    return splay(v)

def find(v, key):
  if v == None:
    return None
  if key == v.key:
    return splay(v)
  if key < v.key and v.left != None:
    return find(v.left, key)
  if key > v.key and v.right != None:
    return find(v.right, key)
  return splay(v)

def split(root, key):
  if root == None:
    return None, None
  root = find(root, key)
  if root.key == key:
    set_parent(root.left, None)
    set_parent(root.right, None)
    return root.left, root.right
  if root.key < key:
    right, root.right = root.right, None
    set_parent(right, None)
    return root, right
  else:
    left, root.left = root.left, None
    set_parent(left, None)
    return left, root 

def insert(root, key):
  left, right = split(root, key)
  root = Node(key, left, right)
  keep_parent(root)
  return root

def merge(left, right):
  if right == None:
    return left
  if left == None:
    return right
  right = find(right, left.key)
  right.left, left.parent = left, right
  return right

def remove(root, key):
  root = find(root, key)
  set_parent(root.left, None)
  set_parent(root.right, None)
  return merge(root.left, root.right)

很明显，性能取决于选择的正确算法。但同样明显的是，性能还应该取决于所选择的语言特性（这在解释型 Python 的情况下特别重要），即使使用正确的算法，错误的选择也会降低它。

问题：有没有办法（除了模拟）来确定哪些 Python 工具更快，哪些更慢？例如，哪些库是用 C 编写的（“快速”），哪些是用 Python 编写的（“不那么快”）？或者（有条件地）在不同类型中搜索或排序的速度是否相同？等等。

它可以是一些内置工具，也可以是文档中的一个奇迹页面。

目的：实用 - 编写快速运行的程序。我不要求对奇异组合进行理论比较。

我不知道为什么当我在 PyCharm 中以分步模式运行教程（下面的代码）时，每行都有一个断点（Shift+F9 开始，然后是 F8 每一步），我可以看到__iter__类被输入了myRange，但这是它进入__iter__类的方式MyGeneratorRange，我没有看到它 - 看起来好像main执行仍然在类中。

然而，如果你__iter__在这个类中放置一个调试打印，你可以看到它每次都应该出现。并且结果是正确的。很可能，我不知道 PyCharm 中的某些内容，但不清楚究竟是什么。请建议它可能是什么 - 类是相似的。

Chernyshov 教程中的代码（删除了不必要的行，代码是为几个示例设计的）：https ://github.com/MADTeacher/python_basics/blob/master/part5/operations_overloading_3_1.py 。

class MyRange:
    def __init__(self, start, stop, step=1):
        self.start = start
        self.stop = stop
        self.step = step
        self.count_value = 0

    # Сюда вижу, как заходит
    def __iter__(self):
        self.count_value = self.start - self.step
        return self
  
    def __next__(self):
        if self.count_value+self.step >= self.stop:
            raise StopIteration
        self.count_value += self.step
        return self.count_value

class MyGeneratorRange:
    def __init__(self, start, stop, step=1):
        self.start = start
        self.stop = stop
        self.step = step

    # А сюда не вижу, как заходит
    def __iter__(self):
        count_value = self.start - self.step
        while count_value+self.step < self.stop:
            count_value += self.step
            yield count_value

if __name__ == "__main__":

    test_range = MyRange(0, 3)
    for firtst_it in test_range:
        print(f'firtst_it = {firtst_it}')
        for second_it in test_range:
            print(f'second_it = {second_it}, '
                    f'firtst_it*second_it = {firtst_it*second_it}')

    test_range = MyGeneratorRange(0, 3)
    for firtst_it in test_range:
        print(f'firtst_it = {firtst_it}')
        for second_it in test_range:
            print(f'second_it = {second_it}, '
                    f'firtst_it*second_it = {firtst_it*second_it}')

调试示例没有产生我期望的结果。可能不完全理解等待和通知逻辑。以下是来自 PuCharm 的预期和收到的结果，其中包含许多评论 + 代码。请解释什么是错的。对理解的有用建议也非常感谢。

脚本的预期内容：

读取器进程无休止地打印该组合（“我们要打印这个”+ 10 次“并打印这个”），无休止地向写入器进程发送锁的释放。Writer 定期打印组合（“条件”+“然后我们等待”）。

会发生什么（描述）：

writer1 进程挂在 cond.wait() 行上，可能没有收到来自 reader 进程的 cond.notify。为什么阅读器进程不循环发送 cond.notify 10 次尚不清楚。应该是卡在第一个了。
PуCharm 给出了一些关于 cond.notify 的警告，但我无法在谷歌上搜索它们的含义，例如 synchronize.py 中的 Python 方法的逻辑尚不清楚。在这种情况下，lock is notowned 的含义也不清楚。

会发生什么（屏幕）：

Process Process-1:
Traceback (most recent call last):
  
File "C:\Users\Serge\AppData\Local\Programs\Python\Python310\lib\multiprocessing\process.py", line 315, in _bootstrap
    self.run()

  File "C:\Users\Serge\AppData\Local\Programs\Python\Python310\lib\multiprocessing\process.py", line 108, in run
    self._target(*self._args, **self._kwargs)

  File "C:\Users\Serge\PycharmProjects\pythonProject\main.py", line 10, in reader
    cond.notify ()  #что-то не так 

  File "C:\Users\Serge\AppData\Local\Programs\Python\Python310\lib\multiprocessing\synchronize.py", line 271, in notify
    assert self._lock._semlock._is_mine(), 'lock is not owned'

AssertionError: lock is not owned

хотим это печатать

и печатаем это

зашли сюда

condition

编码：

from multiprocessing import Process, Condition
import time

def reader(cond):
    while True:
        print('хотим это печатать')
        for x in range (10):
            print('и печатаем это')
            cond.notify ()  #что-то не так 
            print('но не печатаем даже это')
            time.sleep(1)


def writer1(cond):
    print('зашли сюда')
    with cond:
        print('condition')
        cond.wait()              #зависаем здесь?
        print('и тут дождались') #не печатается эта строка

if __name__ == '__main__':
    condition = Condition()
    new_process = Process(target=reader, args=(condition,))
    new_process.start()
    time.sleep(3)
    new_process1 = Process(target=writer1, args=(condition,))
    new_process1.start()

在此过程中，我无法更改公共 Manager 命名空间中的嵌套列表（=二维矩阵）（因此，信息也不会进入main）。即：在下面的例子中，ns.my_list[1] 没有取列表t的值（我在调试的时候把问题简化到最小，以免把所有的东西都放在这里）。同时，在调试打印中很清楚 ns.my_list[1] 正是一个列表，即 从逻辑上讲，它应该取列表 t 的值。我在 python.readthedocs.io 上仔细阅读了有关代理对象的信息，但没有看到任何相关内容。请提出是什么原因。

from multiprocessing import Process, Manager

def process_work(ns):
    t = [1,2,3,4]
    ns.my_list[1]=t
    print ('type of ns.my_list[1]:', type(ns.my_list[1])) # <class 'list'>
    print('ns.my_list[1]', ns.my_list[1])                 #ns.my_list[1] [0, 0, 0, 0]

if __name__ == '__main__':
    mgr=Manager()
    namespace=mgr.Namespace()
    namespace.my_list=mgr.list()
    namespace.my_list= [[0] * 4] * 3 # матрица 3(l)х4(n)

    new_process = Process(target=process_work, args=(namespace,))
    new_process.start()
    new_process.join()

（使用一个简单的列表 - 一维矩阵，一切正常，一切都通过数组工作，但我希望能够返回多维数组/列表列表，其中每一行都由一个单独的进程处理。你可以使用一个- 通过 Array 的维数组，但我不想像那样限制它 - 一旦被截断的知识是不够的）。

Phyton 文档和 Internet 上的多进程使用锁的示例在我复制时不提供竞争保护 - 示例的输出不是按恒定顺序，但在每次运行时输出顺序是随机的。确保列表保持恒定顺序的唯一方法是在末尾添加 p.join() ，但随后锁就失去了意义。是什么原因？浪费了很多时间，我不明白。示例 1 取自http://python-3.ru/page/multiprocessing。

from multiprocessing import Process, Lock

def printer(item, lock):
"""
Выводим то что передали
"""
lock.acquire()
try:
    print(item)
finally:
    lock.release()

if __name__ == '__main__':
lock = Lock()
items = ['tango', 'foxtrot', 10]

for item in items:
    p = Process(target=printer, args=(item, lock))
    p.start()

文档中的示例代码 ( https://python.readthedocs.io/en/stable/library/multiprocessing.html#exchanging-objects-between-processes ) - 17.2.1.4。进程之间的同步

from multiprocessing import Process, Lock

def f(l, i):
l.acquire()
try:
    print('hello world', i)
finally:
    l.release()

if __name__ == '__main__':
lock = Lock()

for num in range(10):
    Process(target=f, args=(lock, num)).start()

我正在学习 Python。仔细，饶有兴致。很长一段时间以来，我都试图理解带有 RLock() 类型组合的示例是如何工作的，而无需稍后在文本中调用必要的 lock.acquire() 和 lock.release() 方法。我在 RLock 或 docs-python.ru/ 上的描述中没有看到任何迹象。最终在谷歌上搜索到“在这种情况下，with 语句在进入时调用 lock.acquire()，在退出时调用 lock.release()。” ( https://digitology.tech/posts/kontekstnye-managery-v-python/ ) Phyton 的学生应该如何自己（用他们的大脑）理解这一点？这从何而来？（如果答案涉及潜在的类似问题，那就太好了）

代码示例：

    class Example1:
        def __init__(self):
            self.lock = RLock()

        def example_of_method (self):
            with self.lock:
                print ('lock.acquire() was just called somehow')    

使用 get_event_loop() 时，所有脚本都为我工作，但我收到弃用警告“DeprecationWarning：没有当前事件循环”（“没有当前事件循环”）。据我了解，在 Python 3.10 之前的某一天，这很有可能会停止工作。总的来说，我不太喜欢带有未解决警告的风格，他们有时会在之后安排有趣的生活:-)

1. 现在有没有一种简单的方法来使用其他东西，这样警告就不会出现？
2. 这条消息的物理意义是什么？这是所需循环的某个实例 - 然后在 run_until_complete 中启动。这是什么意思：“没有当前的事件循环”，但那是什么？（显然，单线程单循环的故事看起来很奇怪，但 PEP 492 在第一行明确指出“此 PEP 假定异步任务由事件循环调度和协调”，即此循环基础）。（Python刚刚开始学习，所以如果问题不是很深，我很抱歉）。

这是一个示例代码：

    import asyncio

    async def demo():
        print(await out())

    async def out():
        return "Тест"

    event_loop = asyncio.get_event_loop() #к этой  строке предупреждение
    event_loop.run_until_complete(demo())

  

我正在学习 Python。在多处理教程中，向进程添加了调试打印。该示例本身有效，但从该过程中打印“测试消息”不起作用。在流的类似示例中，从流中打印是有效的。搜索没有帮助。请解释为什么它不起作用，或者什么是聪明的阅读:-)

from multiprocessing import Process, Queue

def sq(value, q):
    print('test message')
    q.put(value**2)

if __name__ == "__main__":
    number = 2
    q = Queue()
    proc = Process(target=sq,args=(number, q))
    proc.start() 
    proc.join() 
    while not q.empty():
        print(q.get(), end="  ")

from threading import Thread
data_from_file=[]

def thread_read (file_name):
    with open(file_name, 'r',encoding="utf-8") as f:
        str1=f.read()
        f.close
        data_from_file.append(str1)
    return

if __name__ == "__main__":
    file_r="read_thread.txt"
    new_th1=Thread (target=thread_read,args=(file_r,))
    new_th1.start()
    input()   
    str_r=str(data_from_file)
    print('str_r:', str_r)

我喜欢学习 Python。在一次训练任务中，我遇到了我的脚本难以理解的行为。我已经挖掘了几个小时，调试指定了问题，但被进一步卡住了。请帮忙：

• 为什么脚本只有在我们引入人为延迟 - input() 时才能相对正确地工作？（需要什么而不是延迟或至少我没有研究过的东西？:-)

• 我通常选择正确的方法来通过外部变量从流中返回结果？（引入了一个要返回的列表，因为 StackOverflow，当被问及如何将流的结果传递给 main 时，建议（不是我）这种方法。）

• 更新：这个问题在下面得到了回答：“为什么即使工作正常，打印字符串时的最终结果也不是：'Test'，而是 ['Test']？” 谢谢Enikeyshchik！

细节：

• 任务：以流的形式从文件中读取，将结果返回给 main。

• read_thread 文件包含单词“Test”。

• 设置调试打印打印和调试输入：如果没有输入运行，那么调试打印的结果是不正确的：str_r: [] 如果有输入运行，那么更准确地说：str_r: ['Test']