主页 / user-642011

Максим Намазов's questions

Martin Hope
AsLimbo
Asked: 2024-12-08 00:31:17 +0800 CST
  • 5

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

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
Martin Hope
AsLimbo
Asked: 2024-12-02 16:40:33 +0800 CST
  • 5

迭代器对象不是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() 函数实际上对列表做了什么？

python
Martin Hope
Максим Намазов
Asked: 2024-11-23 21:17:46 +0800 CST
  • 7

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

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)
# Вывод:
# переопределили переопределили
# изменили изменили

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

python
Martin Hope
Максим Намазов
Asked: 2024-11-23 03:36:55 +0800 CST
  • 6

我们有一个简单的类：

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 类在结构上没有任何共同点；也许这些没有模板的对象有自己的名称？总的来说，如果您启发我，或者指出我在这里胡说八道，我将不胜感激）

python
Martin Hope
Максим Намазов
Asked: 2024-11-22 20:15:10 +0800 CST
  • 6

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

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)('Тестируем', 'Ещё не закончили', '...')
# Вывод:
# Начало теста
# Тестируем Ещё не закончили ...
# Конец теста

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

python
Martin Hope
Максим Намазов
Asked: 2024-11-02 20:56:50 +0800 CST
  • 7

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

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
Martin Hope
Максим Намазов
Asked: 2024-10-31 00:59:14 +0800 CST
  • 5

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中是不可能的。

python
Martin Hope
Максим Намазов
Asked: 2024-10-29 01:51:44 +0800 CST
  • 5

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

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天，所以请不要攻击我）

python