gw gw's questions

我尝试使用列表包含来解决“两个之和”问题，但遇到了错误：

您是否忘记了理解目标周围的括号？

主要代码：

nums = [3,2,4]
target = 6
for x in range(len(nums)):
    if target - nums[x] in nums[x+1:len(nums)]:
        print([x, nums.index(target - nums[x], x+1, len(nums))])
        break

主要是获取一个元素列表作为输入size>=2，并获取两个数字相加时应该得到的值target。我在代码中提供了一个登录示例。

在尝试创建списковое включение：

outputList = [x, nums.index(target - nums[x], x+1, len(nums)) for x in range(len(nums)) if target - nums[x] in nums[x+1:len(nums)] == True]
print(outputList)

我当然知道我可能会违反编码风格PEP8，但为了学习，可以远离编码风格。

索引的预期输出为列表：

[1,2]

基于这一行的实现：

new_list = [x for x in range(1, 10) if x % 2 == 0 if x % 3 == 0]

然而，我的代码的翻译结果是否定的，并且缺少一些东西，我没有注意到它。

更新：

outputList = [[x, nums.index(target - nums[x], x+1, len(nums))] for x in range(len(nums)) if target - nums[x] in nums[x+1:len(nums)] == True]
print(outputList)

添加后[]，我们可以指定多个变量，但输出变为空。

__new__我看到了元类的方法ABCMeta，并试图了解调用该方法时需要传递哪些参数。

 def __new__(mcls, name, bases, namespace, /, **kwargs):
     cls = super().__new__(mcls, name, bases, namespace, **kwargs)
     _abc_init(cls)
     return cls

作为示例，我将创建 abc 并使用它__new__来创建子类的实例。据我了解，__new__它调用一个方法__init__来初始化子类的实例。

示例代码：

class A(metaclass=abc.ABCMeta):
            @abstractmethod
            def func(self):
                raise NotImplementedError

        class B:
            def func(self):
                print("inheritance")

        class C:
            pass

现在我们可以使用以下方法B从注册派生类：Aregister

A.register(B)

而不是像往常一样实例化：

`obj = B()`

据我了解，我们可以调用该方法__new__：

A.__new__(...)

在这个阶段出现的问题是，__new__根据上面这个方法的源代码，我应该将什么作为参数传递给该方法？

我决定检查该方法的作用abc.get_cache_token()，但我不明白为什么在输出令牌时，它总是打印相同的值。根据定义，我想知道什么是缓存版本以及为什么要比较？

令牌是一个不透明对象（支持相等测试），用于标识虚拟子类的抽象基类的当前缓存版本。

import abc
import unittest
from abc import ABC, abstractmethod, ABCMeta

class Test_Environment(unittest.TestCase):
    def test(self):
        class A(metaclass=abc.ABCMeta):
            @abstractmethod
            def func(self):
                raise NotImplementedError

        class B(A):
            def func(self):
                print("inheritance")


        Otoken = abc.get_cache_token()
        obj = B()
        Ntoken = abc.get_cache_token()
        self.assertEqual(Otoken, Ntoken, 'equal')
        print(Otoken, Ntoken)

mc = Test_Environment()
mc.test()

27 27 输出

同时，equal方法中的注释assertEqual没有显示，也没有任何反应。

阅读文档，我发现了一种通过传递参数调用方法的实现。

def printArgs(a, b):
    print(f"a = {a}, b = {b}")

printArgs(*(2,3))
printArgs(2,3)

我不太明白*如果你可以只列出参数而无需指针，为什么要用它来传递参数？

另外，据我了解，传递starred_and_keywords首先发生，因此使用指针传递参数b会引发错误：

printArgs(a=1, *(2,))

Traceback (most recent call last):
  File "C\...", line 4, in <module>
    printArgs(a=1, *(2,))
TypeError: printArgs() got multiple values for argument 'a'

在研究抽象类的时候，遇到一个关于父类的抽象属性的问题。

示例代码：

import abc
from abc import ABC, abstractmethod

class parent(ABC):
    @abc.abstractproperty
    def someMethod(self):
        return "parent class"

class child(parent):
    @property
    def someMethod(self):
        return "child class"

try:
    obj = parent()
    print(obj.someMethod)
except Exception as ex:
    print(ex)

obj = child()
print(obj.someMethod)

结果：

Can't instantiate abstract class parent without an implementation for abstract method 'someMethod'
child class

如果我们使用@abstractproperty，我们是否需要父类中的属性？

UPD：根据解释器的判断，我们可以创建子类的实例，但不能创建父类的实例？即使具有相同的语义？

在尝试reduce()从模块实现方法时functools，我遇到了对迭代器工作原理的误解。使用该方法时iter()，我们接收列表的迭代器seq并将其分配给一个变量seqIter，然后该方法next()将列表的第一个元素传递给该变量value。

然而，当执行循环时，我们使用可迭代对象的for迭代器，而可迭代对象又是列表的迭代器。问题是，在循环的每一圈上它等于什么？xseqIterx

在这段代码中，我们看到了reduce在列表中添加数字的方法的实现：

def reduce(func, seq):
    seqIter = iter(seq)
    value = next(seqIter)
    for x in seqIter:
        value = func(value, x)
    return value

list = [1,2,3]
print("Sum seq is:", reduce(lambda x,y: x+y, list))

结果：

python .\reduceImplemention.py
Sum seq is: 6

在尝试缩短代码时，出现以下结果：

def reduce(func, seq):
    value = next(iter(seq))
    for x in iter(seq):
        value = func(value, x)
    return value

list = [1,2,3]
print("Sum seq is:", reduce(lambda x,y: x+y, list))

根据字符串的解释以括号开头（如数学中一样）的规则，应该先执行表达式iter(seq)，然后执行字符串的其余部分。我们还使用 方法将列表迭代器传递iter()到循环中。然而，结果变成：forseq

python .\reduceImplemention.py
Sum seq is: 7

问题可能出在循环中for，因此我们创建一个变量seqIter并为其赋值iter(seq)，并在循环中将其更改为for x in seqIter。结果还是一样：

python .\reduceImplemention.py
Sum seq is: 7

因此，问题是：为什么该方法next没有在方法代码块的最开始处应用reduce？还是循环条件？

我创建了一个类Car并添加了几个函数。添加汽车属性后，您需要显示有关汽车（即对象）的所有数据。当print(brichka)输出时<__main__.Car object at 0x000002127E7A6BA0>，即类位置、名称、对象类型和内存地址。我尝试使用列表来实现输出，或者更准确地说，使用隐式循环迭代器for并添加到列表中info。但是，出现了问题：如果我没有声明列表，我如何迭代object以及为什么编译器不会命中？info.append()而且，为什么self它不能成为迭代的对象（也许答案就在第一个问题中）？因此，我无法2+2以任何可读的形式添加和显示对象的属性。

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def _Property(self, isProperty):
        self.isProperty = isProperty

    def Get_Car(self):
        for prop in self:
            if not prop.startswith('_'):
                info.append(prop)
        return info


brichka = Car("Toyota", "Mark")
brichka._Property(str(input()))
print(brichka.Get_Car())

UPD：总的来说，我知道你可以closure使用decorator.我得到这样的东西：

def Car(func):
    def Has_the_property(*_property):
        print(func(*_property))
    return Has_the_property

def Some_property(*_property):
    return f"{_property}"

addProperty = Car(Some_property)
addProperty(str(input()))

然而，当尝试通过类实现它时，显示有关对象的信息很困难。

使用 传递参数的方法keyword *args или **kwargs。作为这些关键字的实现示例，实现了该类Car：

class Car():
    def __init__(self, *args):
        self.speed = args[0]
        self.color = args[1]

audi = Car(200, 'red')
bmw = Car(250, 'black')
mb = Car(190, 'white')

print(audi.color)
print(bmw.speed)

我们可以看到，创建类的对象时Car，参数被传递给方法__init__，然后从数组中赋值args。

问题：如果我们使用args通常的参数列表来代替，是否会有显着差异或什么也不会发生？

UPD：根据答案和评论，我想到了使用这些的成功示例keywords。基本上，将所有参数传递到一个堆中然后写入或处理它们会很方便。例如：

import logging
logging.basicConfig(filename='example.log',
                    level=logging.INFO)

def logger(func):
    def log_func(*args):
        logging.info(f'Running "{func.__name__}" with arguments {args}')
        print(func(*args))

    return log_func

def add(x, y):
    return x+y

def sub(x, y):
    return x-y

add_logger = logger(add)
sub_logger = logger(sub)

add_logger(3, 3)
add_logger(4, 5)

sub_logger(10, 5)
sub_logger(20, 10)

我们得到结果：

python .\ClosureFuntcionsPython.py
6
9
5
10

cat .\example.log
INFO:root:Running "add" with arguments (3, 3)
INFO:root:Running "add" with arguments (4, 5)
INFO:root:Running "sub" with arguments (10, 5)
INFO:root:Running "sub" with arguments (20, 10)

我发现了这个实现循环队列的例子，但我不太明白 的含义 if((self.tail + 1) % self.size == self.head)，如果你可以使用队列大小：(self.tail == self.size - 1)或者也可以在增加变量的(self.tail < self.size)情况下更改它。也许有一些关于数组溢出的主题，我只是不太明白如何进行调试，因为我使用ide并且不明白如何以常规方式进行调试。elsetailAtomcmd

import random

class MyCircularQueue():
    def __init__(self, size):
        self.size = size
        self.queue = [None] * size
        self.head = self.tail = -1

    def enqueue(self, data):
        if((self.tail + 1) % self.size == self.head):
            print("The queue is full\n")
        elif (self.head) == -1:
            self.head = 0
            self.tail = 0
            self.queue[self.tail] = data
        else:
            self.tail = (self.tail +1) % self.size
            self.queue[self.tail] = data

    def dequeue(self):
        if(self.head == -1):
            print("The queue is empty\n")
        elif(self.head == self.tail):
            temp = self.queue[self.head]
            self.head = -1
            self.tail = -1
            return temp
        else:
            temp = self.queue[self.head]
            self.head = (self.head + 1) % self.size
            return temp

    def printqueue(self):
        if(self.head == -1):
            print("Is empty, i cant print\n")

        elif(self.tail >= self.head):
            for i in range(self.head, self.tail + 1):
                print(self.queue[i], end = " ")
            print()
        else:
            for i in range(self.head, self.size):
                print(self.queue[i], end = " ")
            for i in range(0, self.tail + 1):
                print(self.queue[i], end = " ")
            print()

que = MyCircularQueue(5)
for x in range(que.size):
    que.enqueue(random.randint(1, 10))

que.printqueue()

UPD：我将条件更改为self.tail == self.size - 1，并将增量设置为self.tail。显示队列后，发现没有添加新元素，并显示队列已满的消息。我决定更改输出，不显示元素本身，而是显示其在队列中的索引。事实证明，删除是从左到右进行的，添加是从右侧进行的。

Before Delete: 0 1 2 3 4 After Delete: 1 2 3 4 After additional number: 1 2 3 4 0

事实证明，如果您设置增量，则它tail不会重置，并且始终具有适合新条件的最后一个值。

UPD2：在本文中找到了方法实现的示例isEmpty()

我想跟踪桌面和应用程序中发生的所有事情。我看到很多连接摄像头来跟踪流中对象的例子，但是如何跟踪监视器上的对象呢？如果有的话我可以阅读手册。

有一个student基于表的类Student：

public class Student
    {
        public static int id_account { get; set; }
        public static int id_student { get; set; }
        public static string second_name { get; set; }
        public static string name_ { get; set; }
        public static string patronymic { get; set; }
        public static int id_group { get; set; }
        public static DateTime date_birthday { get; set; }
        public static string number_phone { get; set; }
        public static string number_phone_parent { get; set; }
        public static string number_phone_parent_second { get; set; }
        public static string series_passport { get; set; }
        public static string number_passport { get; set; }
        public static string code_dep { get; set; }
        public static byte[] photo { get; set; }
        public static string login { get; set; }
        public static string password { get; set; }
        public static string id_specialization { get; set; }
        public static string number_course { get; set; }
        public static string char_group { get; set; }
        public static string commerce { get; set;}
    }

我需要拉出来id_group，所以我指定student[5]。但是发生了一个错误，我超出了范围，铺设后我明白工作表中只有 1 个元素。可能是因为我以 . 的形式从数据库中卸载DataTable。问题是如何从工作表中提取元素

不明白为什么他不显示在TextBlock

用户.cs：

class User
    {
        public string name { get; set; } = "IVAN";
        public string surname { get; set; } = "IVANOV";
    }

主窗口.xaml：

<StackPanel Orientation="Vertical" HorizontalAlignment="Center" VerticalAlignment="Center">
            <TextBox Width="130" Height="30"/>
            <TextBox Width="130" Height="30" Margin="0,10,0,0"/>
        </StackPanel>
        <StackPanel VerticalAlignment="Center" HorizontalAlignment="Right" Background="Black" Width="130" Margin="10">
            <TextBlock Text="{Binding name}" Foreground="White"/>
            <TextBlock Text="{Binding surname}" Margin="0,10,0,0" Foreground="White"/>
        </StackPanel>
        <Button Width="130" Height="30" HorizontalAlignment="Center" VerticalAlignment="Bottom" Margin="10" Content="REFRESH" Click="Button_Click"/>

主窗口.cs：

        private User user { get; set; }
        public MainWindow()
        {
            InitializeComponent();
            //user = DataContext as User;
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            DataContext = user;
        }

更新：决定让它变得更难。现在我们需要将数据从TextBox推送到User。但是显然没用，pass nullinuser

主窗口.cs：

private void Button_Click(object sender, RoutedEventArgs e)
        {
            user = DataContext as User;
            DataContext = user;
        }