尝试在Python的不同变体中重现竞争条件。以下是一个例子：

import threading, time
count = 0

def counter():
    global count
    c = count # 100 потоков одновременно изменили переменную c, присвоив ей значение count + 1, то есть 0+1 = 1
    time.sleep(0.1) # потоки заснули
    count = c + 1 # Потоки проснулись и просто присвоили переменной count значение 0+1 100 раз.
    print(count) # печать count после повторного присвоения единицы.

for t in range(100):
    thr = threading.Thread(target=counter)
    thr.start()

（修改）
这里100个线程进入函数，给变量counter赋值，然后睡眠0.1秒。在睡眠状态下，线程会释放GIL，这就是它们随后尝试同时增加的原因。然而，问题不在于线程捕获相同的状态。事实上，在给定的例子中，变量 count 不能以任何方式改变，因为变量始终等于 1，并且每个线程进入第 135 行，只是将2 分配给该变量，这是始终的事实的结果。这里没有竞争条件——GIL 成功阻止多个线程获取锁。我们得到以下输出：countccount = c + 1count = 0ccountcount = 2

#...
# 1
# 1
# 1
# 1
# 1
# 1
# 1
# 1

然后我尝试稍微改变一下这个功能：

import threading, time
count = 0

def counter():
    global count
    time.sleep(0.1)
    count = count + 1
    print(count)

for t in range(100):
    thr = threading.Thread(target=counter)
    thr.start()

与前一种情况相比，这里唯一的区别是，我们不是创建中间变量，而是count用其自身增加它。除此之外，一切都一样——100 个线程进入该函数，休眠 0.1 秒，这会导致GIL被释放，并且变量会增加count = count + 1。但是，竞争条件并没有发生！结论：

#...
# 94
# 95
# 96
# 97
# 98
# 99
# 100

变量count等于100，为什么会出现这种情况？看起来增量操作 += 是原子的。也就是说，可以假设在这个例子中，由于字节码级别操作的原子性，GIL 不允许多个线程同时工作。

语境

有一个邮件管理器。

每封邮件都包含一个时间戳、一个发件人和一份收件人列表。

时间戳指定了新闻稿的发送时间，可以是：

• 一次性(2025/01/15 12:30)
• 定期（每 3 小时）
• 从某个日期开始定期更新（每月 3 日 15:30）

每个用户的收件人总数上限是有限制的（默认为 500）。

创建新邮件时，如果其创建日期在已创建日期的 24 小时内，则此新邮件的收件人数量将从用户的收件人限制中减去。也就是说，限制与日期以及在该日期创建邮件的用户相关。

24小时内最多可以发送用户收件人的数量限制。

问题

由于创建邮件时没有设置时间限制，用户可以一次创建多封邮件，这些邮件会在24小时内生效，突破了用户数量的限制。

例子：

假设我们同时安排了 2 封定期邮件。

然后在惰性计算期间第一次将限制考虑在内。如果我们将第二次邮寄的日期推迟 2 个月，由于我们一直在偷懒计算新日期并且它不断更新，因此限制仍然会被正确计算。

有一个函数可以使用 time 模块将输入的时间转换为秒：

def set_time(
        Y=localtime(time())[0],
        m=localtime(time())[1],
        d=localtime(time())[2],
        H=localtime(time())[3],
        M=localtime(time())[4],
        S=localtime(time())[5]):
    Y_f = Y
    m_f = m
    d_f = d
    H_f = H
    M_f = M
    S_f = S
    
    formats = f"%Y-%m-%d %H:%M:%S"
    date_format = f'{Y_f}-{m_f}-{d_f} {H_f}:{M_f}:{S_f}'
    print(date_format)
    date_format_struct = strptime(date_format, formats)
    date_format_like_seconds_f = mktime(date_format_struct)
    return date_format_like_seconds_f

用户有机会输入并非所有参数 - 在这种情况下，未输入的参数将设置为默认值。并且右边缘的参数全部填写也没有问题，例如：

set_time(H=15, M=10, S=10)
#Вывод : 2025-1-8 15:10:10

然而，例如，如果用户只输入小时，则小时参数右侧的时间将被设置为触发该功能时的时间，这是不可接受的。

set_time(H=15)
#Вывод : 2025-1-8 15:19:2

我试图确保输入参数右侧的时间重置为零，即它等于“00”或“01”，并且输入参数左侧的时间始终设置到现在。也就是说，当输入set_time(H=15)时，参数M和S将等于“00”，参数d、m、Y将等于当前时间。我使用 match/case 实现了以下解决方案：

def set_time(
        Y=localtime(time())[0],
        m=localtime(time())[1],
        d=localtime(time())[2],
        H=localtime(time())[3],
        M=localtime(time())[4],
        S=localtime(time())[5]):
    Y_f = Y
    m_f = m
    d_f = d
    H_f = H
    M_f = M
    S_f = S

    YYf = localtime(time())[0] == Y_f
    mmf = localtime(time())[1] == m_f
    ddf = localtime(time())[2] == d_f
    HHf = localtime(time())[3] == H_f
    MMf = localtime(time())[4] == M_f
    SSf = localtime(time())[5] == S_f
    print(YYf, mmf, ddf, HHf, MMf, SSf)

    match YYf, mmf, ddf, HHf, MMf, SSf:

        case True, True, True, True, False, True:
            S_f = '00'
            print('Минуты ')
        case True, True, True, False, False, True:
            S_f = '00'
            print('Минуты ')
        case True, True, False, False, False, True:
            S_f = '00'
            print('Минуты ')
        case True, False, False, False, False, True:
            S_f = '00'
            print('Минуты ')
        case False, False, False, False, False, True:
            S_f = '00'
            print('Минуты')

        case True, True, True, False, True, True:
            print('Часы ')
            M_f = '00'
            S_f = '00'
        case True, True, False, False, True, True:
            print('Часы ')
            M_f = '00'
            S_f = '00'
        case True, False, False, False, True, True:
            print('Часы ')
            M_f = '00'
            S_f = '00'
        case False, False, False, False, True, True:
            print('Часы ')
            M_f = '00'
            S_f = '00'

        case  True, True, False, True, True, True:
            print('Дни ')
            H_f = '00'
            M_f = '00'
            S_f = '00'
        case  True, False, False, True, True, True:
            print('Дни ')
            H_f = '00'
            M_f = '00'
            S_f = '00'
        case False, False, False, True, True, True:
            print('Дни ')
            H_f = '00'
            M_f = '00'
            S_f = '00'

        case True, False, True, True, True, True:
            print('Месяцы ')
            d_f = '01'
            H_f = '00'
            M_f = '00'
            S_f = '00'
        case False, False, True, True, True, True:
            print('Месяцы ')
            d_f = '01'
            H_f = '00'
            M_f = '00'
            S_f = '00'

        case False, True, True, True, True, True:
            print('Года ')
            m_f = '01'
            d_f = '01'
            H_f = '00'
            M_f = '00'
            S_f = '00'

    formats = f"%Y-%m-%d %H:%M:%S"
    date_format = f'{Y_f}-{m_f}-{d_f} {H_f}:{M_f}:{S_f}'
    print(date_format)
    date_format_struct = strptime(date_format, formats)
    date_format_like_seconds_f = mktime(date_format_struct)
    return date_format_like_seconds_f

但它有一个缺点 - 如果您在同一时间点运行该函数，则匹配表达式将不正确并且将选择错误的情况。例如，如果您在 21:24 运行该函数，之前输入了参数 H=21、M=24，则 match 中的大小写将相当于 True、True、True、True、True、True，结果不会匹配。如果您能告诉我如何正确解决这个问题，我将不胜感激）理论上，如果有一种方法可以将用户输入参数的响应和设置默认参数的响应分开，一切都会更简单，但我不这样做不知道这样的方法。
PS：
我根据@DiHASTRO的答案重新表述了条件，它将正常工作（请参阅代码中的注释）：

from time import *


def set_time(
    Y=None,
    m=None,
    d=None,
    H=None,
    M=None,
    S=None,
):
    TIME_PARAMS_COUNT = 6
    TIME_PARAMS_MINIMUMS = ['0000', '01', '01', '00', '00', '00']
    time_params = [Y, m, d, H, M, S]
    if time_params == [None, None, None, None, None, None]:
        time_params = [localtime(time())[0], localtime(time())[1], localtime(time())[2], localtime(time())[3],
                       localtime(time())[4], localtime(time())[5]]

    was_time_param_set = False
    for i in range(TIME_PARAMS_COUNT - 1, -1, -1):

        # 3) вхождение
        if was_time_param_set is True:
            while  time_params[i] is None:
                time_params[i] = localtime(time())[i]

        # 2) второе вхождение
        if time_params[i] is not None:
            was_time_param_set = True

        # 1) первое вхождение
        while time_params[i] is None and was_time_param_set is False:
            time_params[i] = TIME_PARAMS_MINIMUMS[i]

# Алгоритм следующий, происходит последовательная итерация по TIME_PARAMS_COUNT. ( 1) вхождение )Пока значения в time_params[i] is None и was_time_param_set is False
# time_params[i] обнуляется. Как только в в одной из итераций time_params[i] становится не равен None(то есть мы натыкаемся на введённые параметры), ключ was_time_param_set
# переключается на True( 2) вхождение). Введённые параметры при итерации по ним никак не изменяются. Происходит ( 3) вхождение ) в котором цикл while изменяет на localtime(time())[i]
# параметры после введённых, равные None.

    formats = f"%Y-%m-%d %H:%M:%S"
    Y_f, m_f, d_f, H_f, M_f, S_f = time_params
    date_format = f'{Y_f}-{m_f}-{d_f} {H_f}:{M_f}:{S_f}'
    print(date_format)
    date_format_struct = strptime(date_format, formats)
    date_format_like_seconds_f = mktime(date_format_struct)
    return date_format_like_seconds_f

if __name__ == '__main__':
    set_time(H=18, M=45, S=21)
    set_time(M=45, S=21)
    set_time(S=21)
    set_time()
    set_time(H=18)
    set_time(H=18, M=45)

#Вывод:
# 2025-1-9 18:45:21
# 2025-1-9 21:45:21
# 2025-1-9 21:3:21
# 2025-1-9 21:3:2
# 2025-1-9 18:00:00
# 2025-1-9 18:45:00

需要使用相应的索引顺序比较两个列表的元素。使用map()和next()函数的组合：

# Последовательное сравнение элемента по совпадающими индексами двух списков. T.к. map() возвращает объект итератор, таковой необходимо пропустить через next()
g = map(lambda y: y,[1,2,4,3,4,5,6,4,4]) # то же самое можно записать как iter([1,2,4,3,4,5,6,4,4])
s = [i for i in map(lambda x: x == next(g), [1,2,4,3,4,5,6,4,5])]
print(s)
#Вывод: [True, True, True, True, True, True, True, True, False]

然而，当将map()函数本身而不是中间变量g替换到列表生成器中时，输出是截然相反的：

s = [i for i in map(lambda x: x == next(map(lambda y: y,[1,2,4,3,4,5,6,4,4])), [1,2,4,3,4,5,6,4,5])]
print(s)
#Вывод: [True, False, False, False, False, False, False, False, False]

为什么会发生这种情况？

内核->进程->线程图中的是什么？原来一个核心上可以有一个进程，而据说进程和线程没有特别的区别，同时一个进程上可以有多个线程。也就是说，这些可互换概念存在的意义仅仅在于将程序的竞争性执行转移到两个不同的层次上。

1. 线程级别，每个线程（即任务/程序）都可以访问共享资源，并且
2. 在进程级别，每个线程（换句话说，任务或程序）都没有这样的访问权限。

在多个进程中运行单个程序和在具有多个线程的单个进程中运行程序之间实际上没有区别，只是第一种情况下的上下文切换（并发）发生在进程级别，而第二种情况下的上下文切换（并发）发生在同一内存区域中的线程级别？

我们有一个简单的装饰器和一个我们想要添加附加功能的函数：

def wrap(func):
    def mod():
        up = func()
        mod_up = up.upper()
        return mod_up
    return mod

def up_str():
    return 'hello Maksim'

我们可以通过三种方式装饰和调用我们的原始函数：

#1) Просто вызывать функцию wrap c передачей ей в качестве параметра функции uper_str.
print(wrap(up_str)()) #Вывод: HELLO MAKSIM Важным моментом является то, что мы всегда возвращаем в return не результат вызова 
#функции(с круглыми скобочками), а сам объект функции(без круглых скобочек).

# Этап вызова нашей функции ^^^ когдa выполняется return mod, объект функции mod перемещается в область видимости wrap, что образно можно представить так:
def wrap(func):
    mod
# А затем к возвращённому mod применяется оператор круглых скобочек (), которые мы дописали в конце вызова wrap выше. То есть вызывается функция mod() - происходит то же самое, что и в предыдущий раз тело функции mod как бы перемещается в область видимости wrap:
def wrap(func):
    up = func()
    mod_up = up.upper() # эти две строчки сразу возвращаются в виде результата вызова mod() - return mod_up. Это просто образное представление происходящих процессов, чтобы в том числе объяснить, как параметр func может передаться в up = func() - благодаря попадaнию в область видимости wrap.
# (Если что я просто образно представляю порядок выполнения кода)

#2) Переопределить функцию up_str. Логика "превращений" та же только добавляется новое звено: wrap(up_str)-->mod-->up_str. Чтобы активировать переопределённую функцию к ней так же надо добавить оператор круглых скобок () :
up_str = wrap(up_str) 
print(up_str()) #Вывод: HELLO MAKSIM
# В этом случае после переопределения функции up_str мы теряем её исходный функционал, но мы всегда можем сохранить исходную функцию в другую переменную до её переопределения и таким образом ничего не потерять.

#3) Ну и с помощью синтаксического сахара:
@wrap
def up_str():
    return 'hello Maksim'

print(up_str())#Вывод: HELLO MAKSIM

前两种方法中，函数是在函数调用阶段进行修饰的。在后者中，在定义函数的阶段。这导致了以下问题：

1. 当用@修饰时，在定义up_str的阶段，顺序会发生什么？
2. 如何在使用@时同时保留原始函数和修饰后的函数？

迭代器对象不是Python内置的固定构造，而是根据一定规则构造的对象。这些规则意味着迭代器对象或集合对象将被传递给 iter()。如果这是一个迭代器对象，即在其类中描述了next方法 的对象，该方法定义了发出下一个元素并在这些元素耗尽自身时引发 StopIteration 异常的条件，那么 iter() 函数会执行什么操作就这样传递下去吗？还不清楚 iter() 函数对集合对象执行什么操作。我将举一个 for in 循环的例子，理论上，它首先通过 iter() 函数传递传入它的对象（in 之后），然后通过 next() 函数，并在以下情况下停止元素的迭代：停止迭代被称为：

class A:
    def __init__(self, qty):
        self.qty = qty

    def __iter__(self): #Перегружаем оператор взаимодействия с функцией iter(), чтобы он возвращал сам экземпляр т.к. таковой уже является объектом итератором благодаря методу __next__
        return self

    def __next__(self):
            if self.qty > 0 :
                self.qty -= 1
                return '*'
            else : raise StopIteration

a = A(5)
for i in a
    print(i)
#Вывод:
#*
#*
#*
#*
#*

但是，我们可能不会使用下一个方法 ：

class A:
    def __init__(self, qty):
        self.qty = qty

    def __iter__(self):
        return iter(range(self.qty)) # Здесь мы как бы возвращаем изначальный функционал функции iter(), применяя его к объекту-коллекции

a = A(5)

for i in a:
    print(i)
#Вывод:
#0
#1
#2
#3
#4

这是否意味着任何集合对象默认都有一个next方法 ，并且 iter() 函数总是只返回对象本身？但在这种情况下，输出意味着什么：

s = [1,2,3,4,5,6]
c = iter(s)
print(type(c))
#Вывод: <class 'list_iterator'>

iter() 函数实际上对列表做了什么？

当我们创建一个类时，我们似乎有一个模板对象（我的意思是缩进类中编写的所有内容）和原始对象本身，可以通过类名访问它（类名是到此的链接）原始对象）：

class InCap:
    name = 10

InCap.name = 203 #мы можем убедиться в существовании оригинального объекта, сразу изменив его атрибут
print(InCap.name) # Вывод : 203

在课程和教育材料中（至少在我学习的课程和教育材料中）据说我们可以创建类的实例，但事实证明我们正在创建原始对象的实例，而不是类的实例，因为默认情况下，实例继承所有属性，包括父属性（类模板中描述的属性）和本地属性（我们可以添加到原始属性中的属性）：

Namer = InCap() #создали экземпляр оригинального объекта
# Добавим в оригинальный объект новый атрибут:
InCap.Unname = 30
print(f'новый атрибут оригинального объекта: {Namer.Unname}, родительский атрибут оригинального объекта: {Namer.Name}')
# Вывод: новый атрибут оригинального объекта: 30, родительский атрибут оригинального объекта: 203

我们看到实例从原始对象继承了 Name 和 Unname 属性（而不是从没有 Unname 属性的类继承），并且只有在我们覆盖它们之前才会发生这种情况：

Namer.Unname = 'переопределили'
Namer.Name = 'переопределили'
print(Namer.Unname, Namer.Name)# Вывод: переопределили переопределили Теперь это локальные атрибуты.
print(InCap.Name, InCap.Unname)# Вывод: 203 30

原始对象的属性保持不变，上面的更改不会影响本地属性：

print(Namer.Unname, Namer.Name)
print(InCap.Name, InCap.Unname)
# Вывод:
# переопределили переопределили
# изменили изменили

总而言之，我从来没有听说过创建原始对象的实例并从中继承属性，到处都有类的实例，但实际上事实证明模板与它无关，这种表述会导致混乱，至少对我来说。总的来说，如果您证实或反驳我的猜测，我会很高兴，提前感谢您的回答。

我们有一个简单的类：

class Test:
    n = 5

# Создадим два экземпляра этого класса:
name1 = Test()
name2 = Test()
print(f'{name1.n}, {name2.n}, {Test.n}') # 5, 5, 5

现在让我们尝试更改其中一个实例，然后更改 Test.n：

name1.n = 10
print(name1.n) # 10 (Test.n и name2.n на данный момент равны 5)
Test.n = 15 # Изменение самого объекта класса должно повлиять на все ссылки, связанные с ним, но эти изменения не коснуться ссылки name1
print(f'{name1.n}, {name2.n}, {Test.n}') # 10, 15, 15 (соответственно можно предположить, что объект name1 теперь не является объектом класса Test)
#Мы можем проверить принадлежность name1 классу Test:
print(isinstance(name1, Test) # True

有人向我解释说，此时实例有自己的属性 n，它将覆盖（覆盖）父属性，即从类继承的属性。但随后还不清楚为什么：

> print(isinstance(name1, Test) # True

我猜测我们现在实际上有两个同名的 Test 类实例 - 第一个由 name1 引用，第二个由 name2 引用。当我们编写 Test.n 时，Python 与 name2 引用的实例完全相同。如果是，那么 name1 引用的 Test 实例的结构在哪里定义？我们基本上可以在这个实例中创建自己的属性，访问它的唯一方法是通过 name1 链接：

name1.l = 24

最后，它可能与 Test 类在结构上没有任何共同点；也许这些没有模板的对象有自己的名称？总的来说，如果您启发我，或者指出我在这里胡说八道，我将不胜感激）

有两个装饰器，第一个没有附加函数；它立即将我们添加附加功能的函数和同一函数的参数作为参数：

def test(*args): #Наша функция, тест, которая будет принимать произвольное количество параметров.
    print(*args)

def call_start_end(func, *args):
    print('Начало теста')
    func(*args)
    print('Конец теста')

call_start_end(test, 'Тестируем', 'Ещё не закончили', '...')
# Вывод :
# Начало теста
# Тестируем, Ещё не закончили, ...
# Конец теста

第二个装饰器已经使用了一个附加函数来包装包装器：

def test(*args):
    print(*args)

def prewrapper(func): #Обёртка для обёртки, которая принимает функцию.
    def call_start_end(*args): # Сама обёртка, которая принимает аргументы для функции, функционал которой мы расширяем.
        print('Начало теста')
        func(*args) 
        print('Конец теста')
    return call_start_end

prewrapper(test)('Тестируем', 'Ещё не закончили', '...')
# Вывод:
# Начало теста
# Тестируем Ещё не закончили ...
# Конец теста

因此，如果您解释为什么我们应该用另一个包装器来包装包装器，我们将函数单独传递到其中，而不是像装饰器的第一个示例中那样，不将它们传递到一个包装器中，我将不胜感激？在我看来，正是因为此时此刻，装饰器在一定程度上难以理解；目前还不清楚为什么它们需要另外包装在另一个包装器中。预先感谢您的回答。

我在研究格式化方法时遇到了这个事情：

test = 'Name'
exec('{0} = {1}'.format(test, 10))
a = Name # Python жалуется на Unresolved reference 'Name' При этом код воспроизводится без ошибок.
print(a) # Вывод: 10  Где в данный момент хранится переменная Name?
print(Name-5) # Вывод: 5
print(test) # Вывод: 'Name'

第一个问题是，它是什么以及为什么它有效？这是使用 % 格式的类似条目：

exec('%s = %d' % (test, 10)) # Работает так же как и метод .format() - без проблем.

但由于某种原因，使用 f 格式的类似条目不再有效：

exec(f'{(test := 10)}') # Эквивалентная запись с помощью f-форматирования выдаёт NameError: name 'Name' is not defined. Did you mean: 'name'? То есть как и должно работать.

实际上，第二个问题是，在重现上述代码时，f 字符串与其他类型的格式化有何不同？为什么这里不起作用？

Python中是否有类似的方法.append，只允许您添加值并替换变量中的前一个？你需要类似的东西：

saver = 0    # Переменная saver в данном случае как бы сохраняет поочередно 
             # значения из цикла. Ну это в идеале :)
while True :
    vvod = input('Введите число')

    if saver == 0 or vvod < largest or vvod != 'done'  :
        saver.append(vvod)

    line = vvod


    if saver == 0 :
        largest = saver

    if line == 'done' :
        print(f'Цикл завершен! {largest}')
        break
        
    if line > largest :
        largest = line

该程序将计算输入的最大数字（我没有添加函数来检查输入，因为这只是一个示例）。一般来说，我还没有发现任何可以这种方式工作的东西。具有固定数量值的列表可能是合适的，但据我所知，这在Python中是不可能的。

下面的代码片段是一个简单的生成器，用于从两个值创建一系列数字：

def dip(start, stop, part):
    step = (stop-start)/part
    while True:
        yield start
        start = start + step
        if start >= stop:
            break

为了显示生成的值，我写了：

print(list(dip(0, 10, 4)))

输出：[0, 2.5, 5.0, 7.5] 那么，告诉我如何在函数本身中返回这个列表，以便可以通过编写以下内容来输出相同的内容：

c = dip(0, 10, 4)
print(c)

例如，据我了解，这样的构造根本行不通，因为在While True循环结束时，内存中尚未存储任何值：

def dip(start, stop, part):
    step = (stop-start)/part
    while True:
        yield start
        start = start + step
        if start >= stop:
            break
    return list(start)
c = dip(0, 10, 4)
print(c)

输出： <generator object dial at 0x000002C1A5C557E0> 因此我们需要以某种方式在 While True 循环之外输出start变量的值。也许这是一个愚蠢的问题，我只学习了5天，所以请不要攻击我）