全部问题(coding)

这是我第一次使用 OOP，我想让 SubWindow 类继承 MainWindow 类的所有属性，但是self.root应该tk.Toplevel()这样做tk.Tk()：

import tkinter as tk

class MainWindow:
    def __init__(self, size, title):
        self.root = tk.Tk()
        self.root.geometry(size)
        self.root.title(title)
        
    def packAll(self):
        for widget in self.root.children:
            self.root.children[widget].pack()
            
class SubWindow(MainWindow):
    def __init__(self, size, title):
        super().__init__(size, title)

如果我将其放在self.root = tk.Toplevel()后面super().__init__(size, title)，它仍然会创建另一个 tkinter 实例。私有变量也不起作用。我在网上找不到解决方案。我该如何解决这个问题？

我一直在学习 Java 中的文件系统管理。我偶然发现了 Path 接口下的 resolve 方法的文档。我不明白路径是绝对路径和具有根组件之间的区别。它们不一样吗？

来自文档：

路径解析（路径其他）

根据此路径解析给定的路径。

如果 other 参数是绝对路径，则此方法将返回 other。如果 other 是空路径，则此方法将返回此路径。否则，此方法将此路径视为目录，并根据此路径解析给定路径。在最简单的情况下，给定路径没有根组件，在这种情况下，此方法将给定路径连接到此路径并返回以给定路径结尾的结果路径。如果给定路径具有根组件，则解析高度依赖于实现，因此未指定。

我以为它们的意思是一样的，并在网上搜索，但没有找到任何结果。

我在 C#（.NET8 版本）中处理数字时发现了一些奇怪的行为8.0.400。

我创建了一个自定义类型来包装数字，这是展示行为的最小化代码：

struct Mystery<T>(T value)
    where T : IBinaryInteger<T>
{
    public T Value { get; } = value;

    public int GetByteCount() => Value.GetByteCount();
}

执行代码：

Mystery<BigInteger> mystery = new(short.MaxValue);

// Mystery<BigInteger> mystery = new(new BigInteger(short.MaxValue)); // same behavior

Console.WriteLine(mystery.GetByteCount()); // 4
Console.WriteLine(mystery.Value.GetByteCount()); // 2
Console.WriteLine(((IBinaryInteger<BigInteger>)mystery.Value).GetByteCount()); // 4

输出：

4
2
4

由于我创建了Mystery用于环绕数字的类型，因此我希望mystery.GetByteCount()其行为与 完全相同Value.GetByteCount()。但是，如输出所示，我的代码并未按预期工作。

我哪里做错了？我应该如何修改我的Mystery.GetByteCount()才能使其返回预期结果Value.GetByteCount()？

以下是 NUnit 测试，用于阐明预期行为：

[TestCase(0)] // expect 1, but was 4
[TestCase(byte.MaxValue)] // expect 2, but was 4
[TestCase(short.MaxValue)] // expect 2, but was 4
[TestCase(char.MaxValue)] // expect 3, but was 4
[TestCase(int.MaxValue)] // expect 4, PASSED
[TestCase(long.MaxValue)] // expect 8, PASSED
public void MysteryBigInt_GetByteCount(long value)
{
    Mystery<BigInteger> mystery = new(value);
    BigInteger bigInt = new(value);
    int expectedByteCount = bigInt.GetByteCount();
    Assert.Multiple(
        () =>
        {
            // PASSED
            Assert.That(mystery.Value.GetByteCount(), Is.EqualTo(expectedByteCount));

            // ony passed for int and long
            Assert.That(mystery.GetByteCount(), Is.EqualTo(expectedByteCount));
        });
}

假设我有一个数字num，我想计算范围内[1, n]按字典顺序小于和的正整数的数量num，并且n是某个任意大整数。如果转换后的字符串按字典顺序小于转换后的字符串，则数字按字典顺序x小于数字。我想高效地做到这一点，因为可能很大（例如）。我的想法是使用数字动态规划。ystr(x)str(y)n10^9

本质上，我的想法是，范围内的每个数字[1,n]都可以表示为一串len(str(n))槽位。在每个槽位，其上限要么是 的最后一个位置的数字num（这适用于我们选择尾随零的情况），要么是 的最后一个位置的数字n。这是因为，如果前一个数字已经小于 中的对应数字，num那么我们可以自由选择 中的对应数字以下任何数字n。下面是我在 Python 中尝试执行此操作的代码

from functools import cache

def count(num, n):
    num = str(num)
    n = str(n)
    max_length = len(n)
    @cache
    def dp(indx, compare_indx, tight, has_number):
        if indx == max_length:
           return int(has_number)
        ans = 0
        upper_bound = int(num[compare_indx]) if tight else int(n[indx])
        for digit in range(upper_bound + 1):
            if digit == 0 and not has_number:
               ans += dp(indx + 1, compare_indx, tight and (digit == upper_bound), False)
            else:
               ans += dp(indx + 1, min(compare_indx + 1, len(num) - 1), tight and (digit == upper_bound), True)
        return ans
    return dp(0, 0, True, False)

但是，count(7, 13)输出 35 是错误的，因为 的字典顺序[1, 13]是 [1, 10, 11, 12, 13, 2, 3, 4, 5, 6, 7, 8, 9]，所以count(7, 13)应该是10。有人能帮我吗？

我正在尝试编写一个简短的代码来计算整数的 Hemming 权重，

class Solution {
public:
    int hammingWeight(int n) {
        if(n==0){
            return 0;
        }else{
            int a=1;
            while(a<=(float)n/2){
                a*=2;
            }
            return 1+hammingWeight(n-a);
        }
        
    }
};

然而，对于 n=2147483645，它给出了错误：

Line 9: Char 18: runtime error: signed integer overflow: 1073741824 * 2 cannot be represented in type 'int' (solution.cpp)
SUMMARY: UndefinedBehaviorSanitizer: undefined-behavior solution.cpp:9:18

我不明白为什么，在我的计算中我从来不需要做 1073741824 * 2。另外，如果a<=(float)n/2我不做 而是做 ，我的代码也能正常工作a<=n/2。

这是我的班级层次结构：

readonly class ParentClass {
    public function __construct(
        public string $lastName
    ){
    }
}

readonly class ChildClass extends ParentClass {
    public function __construct(
        public string $firstName,
        public string $lastName
    ){
        parent::__construct($lastName);
    }
}

$child = new ChildClass('John', 'Doe');

我收到一条异常消息“无法修改只读属性 ParentClass::$lastName”。

我读过很多文章或 Stackoverflow 上的问题的答案，但没有人谈论这个案例，或者我没有发现。

我为什么会收到那个错误？

我有一个pl.DataFrame包含如下列表的列：

import polars as pl

df = pl.DataFrame(
    {
        "symbol": ["A", "A", "B", "B"],
        "roc": [[0.1, 0.2], [0.3, 0.4], [0.5, 0.6], [0.7, 0.8]],
    }
)

shape: (4, 2)
┌────────┬────────────┐
│ symbol ┆ roc        │
│ ---    ┆ ---        │
│ str    ┆ list[f64]  │
╞════════╪════════════╡
│ A      ┆ [0.1, 0.2] │
│ A      ┆ [0.3, 0.4] │
│ B      ┆ [0.5, 0.6] │
│ B      ┆ [0.7, 0.8] │
└────────┴────────────┘

此外，我有一个常规的 python 列表weights = [0.3, 0.7]

pl.col("roc")将乘以的一种有效方法是什么？weights即将 列的第一个和第二个元素分别与 的第一个和第二个元素相乘weights？

预期输出如下：

shape: (4, 3)
┌────────┬────────────┐──────────────┐
│ symbol ┆ roc        │ roc_wgt      │
│ ---    ┆ ---        │ ---          │
│ str    ┆ list[f64]  │ list[f64]    │
╞════════╪════════════╡══════════════╡
│ A      ┆ [0.1, 0.2] │ [0.03, 0.14] │ = [0.1 * 0.3, 0.2 * 0.7]
│ A      ┆ [0.3, 0.4] │ [0.09, 0.28] │ = [0.3 * 0.3, 0.4 * 0.7]
│ B      ┆ [0.5, 0.6] │ [0.15, 0.42] │ = [0.5 * 0.3, 0.6 * 0.7]
│ B      ┆ [0.7, 0.8] │ [0.21, 0.56] │ = [0.7 * 0.3, 0.8 * 0.7]
└────────┴────────────┘──────────────┘

我在使用属性名称时遇到了 Spring Boot (3.1.3) 的一个奇怪行为-。以下是示例代码：

@SpringBootApplication
public class DemoApplication {
  public static void main(String[] args) {
    SpringApplication.run(DemoApplication.class, args);
  }
}

@SpringBootTest
class DemoApplicationTests {
  @Value("${application.jokeurl}")
  private String jokeUrl;
  @Value("${application.joke-url}")
  private String jokeDashUrl;

  @Test
  void contextLoads() {
      System.out.println(jokeUrl);
      System.out.println(jokeDashUrl);
  }
}

这是我的application.yml：

application:
  joke-url: url1 #pay attention to dash in property name

当我运行测试时，它会在控制台中打印两行：

url1
url1

我们看到，Spring 将相同的字符串注入到实际上引用不同属性的值中，即@Value("${application.jokeurl}")和@Value("${application.joke-url}")。

现在，如果我再添加一个属性到application.ymlas

application:
  joke-url: url1 #pay attention to dash in property name
  jokeurl:  url2 #no dash in property name

相同的测试打印不同的行：

url2
url2

现在我们看到该属性application.joke-url被忽略application.jokeurl，并再次将相同的字符串注入到引用不同属性的值中。

所以我的问题是这是一个错误还是预期的行为？

我遇到了某种正则表达式问题，尽管我已经在 MATLAB 中编写了代码，但我想使它尽可能通用。

信息：

LipidData是一个 68x2 的表，其中包含一个名称列和Short列，这些列是字符串，例如LPC、PC、AC4PIM2、等等。这个矩阵不会改变，但可能会根据其来源的实际输入数据而变化。SHexCerSQDGLipidDatafoundpattern

foundpattern是一个 N×4 表，在我的示例中 N 为 7。这里唯一相关的列是第一个，称为ISDs，其中包含要检查的字符串（为了可重复性，您可以仅将列复制为单元格数组）。在这里您可以看到两个 MATLAB 表：

输入：

>> LipidData

LipidData =

 68×2 table

                Lipid subclass name                       Short   
___________________________________________________    ___________

{'Diacylated phosphatidylinositol monomannoside'                  }    {'Ac2PIM1'    }
{'Diacylated phosphatidylinositol dimannoside'                    }    {'Ac2PIM2'    }
{'Triacylated phosphatidylinositol dinomannoside'                 }    {'Ac3PIM2'    }
{'Tetraaacylated phosphatidylinositol dimannoside'                }    {'AC4PIM2'    }
{'Anacardic Acid'                                                 }    {'ACar'       }
{'Acetylglucose andrographolide'                                  }    {'AcylGlcADG' }
{'Bis[monoacylglycero]phosphates'                                 }    {'BMP'        }
{'Cholesteryl esters'                                             }    {'CE'         }
{'Ceramide'                                                       }    {'Cer'        }
{'Ceramide alpha-hydroxy fatty acid-dihydrosphingosine'           }    {'CerADS'     }
{'Ceramide alpha-hydroxy fatty acid-phytospingosine'              }    {'CerAP'      }
{'Ceramide beta-hydroxy fatty acid-sphingosine'                   }    {'CerAS'      }
{'Ceramide beta-hydroxy fatty acid-dihydrosphingosine'            }    {'CerBDS'     }
{'Ceramide beta-hydroxy fatty acid-sphingosine'                   }    {'CerBS'      }
{'Ceramide Esterified omega-hydroxy fatty acid-dihydrosphingosine'}    {'CerEODS'    }
{'Ceramide Esterified omega-hydroxy fatty acid-sphingosine'       }    {'CerEOS'     }
{'Ceramide non-hydroxyfatty acid-dihydrosphingosine'              }    {'CerNDS'     }
{'Ceramide non-hydroxyfatty acid-phytospingosine'                 }    {'CerNP'      }
{'Ceramide non-hydroxyfatty acid-sphingosine'                     }    {'Cer_NS'     }
{'Ceramide phosphate'                                             }    {'CerP'       }
{'Cholesterol'                                                    }    {'Cholesterol'}
{'Cardiolipins'                                                   }    {'CL'         }
{'Diacyl/alkylglycerides'                                         }    {'DG'         }
{'Digalactosyldiacylglycerols'                                    }    {'DGDG'       }
{'1,2-diacylglyceryl-3-O-4'-(N,N,N-trimethyl)-homoserine'         }    {'DGTS'       }
{'Ether Oxygenated Phosphatidylcholines'                          }    {'EtherOxPC'  }
{'Ether Oxygenated Phosphatidylethanolamines'                     }    {'EtherOxPE'  }
{'Ether-linked Phosphatidylcoline'                                }    {'EtherPC'    }
{'Ether-linked Phosphatidylethanolamine'                          }    {'EtherPE'    }
{'Fatty Acids'                                                    }    {'FA'         }
{'Fatty acid ester of hydroxyl fatty acid'                        }    {'FAHFA'      }
{'Glucuronosyldiacylglycerol'                                     }    {'GlcADG'     }
{'GM3 Ganglioside'                                                }    {'GM3'        }
{'Hidroxy Bis[monoacylglycero]phosphates'                         }    {'HBMP'       }
{'Hexosylceramide alpha-hydroxy fatty acid-phytospingosine'       }    {'HexCerAP'   }
{'Hexosylceramide non-hydroxyfatty acid-dihydrosphingosine'       }    {'HexCerNDS'  }
{'Hexosylceramide non-hydroxyfatty acid-sphingosine'              }    {'HexCer_NS'  }
{'Lyso 1,2-diacylglyceryl-3-O-4'-(N,N,N-trimethyl)-homoserine'    }    {'DGTS'       }
{'Lyso Phosphatidic acids'                                        }    {'LPA'        }
{'Lyso Phosphatidylcholines'                                      }    {'LPC'        }
{'Lyso Phosphatidylethanolamines'                                 }    {'LPE'        }
{'Lyso Phosphatidylglycerols'                                     }    {'LPG'        }
{'Lyso Phosphatidylinositols'                                     }    {'LPI'        }
{'Lyso Phosphatidylserines'                                       }    {'LPS'        }
{'Monoacyl/alkylglycerides'                                       }    {'MG'         }
{'Monogalactosyldiacylglycerols'                                  }    {'MGDG'       }
{'Oxygenated Cardiolipins'                                        }    {'OxCL'       }
{'Oxygenated Fatty Acids'                                         }    {'OxFA'       }
{'Oxygenated Phosphatidic acids'                                  }    {'OxPA'       }
{'Oxygenated Phosphatidylcholines'                                }    {'OxPC'       }
{'Oxygenated Phosphatidylethanolamines'                           }    {'OxPE'       }
{'Oxygenated Phosphatidylglycerols'                               }    {'OxPG'       }
{'Oxygenated Phosphatidylinositols'                               }    {'OxPI'       }
{'Oxygenated Phosphatidylserines'                                 }    {'OxPS'       }
{'Oxygenated Triacyl/alkylglycerides'                             }    {'OxTG'       }
{'Phosphatidic acids'                                             }    {'PA'         }
{'Phosphatidylbutyl alcohol'                                      }    {'PBtOH'      }
{'Phosphatidylcholines'                                           }    {'PC'         }
{'Phosphatidylethanolamines'                                      }    {'PE'         }
{'Phosphatidyletanol'                                             }    {'PEtOH'      }
{'Phosphatidylglycerols'                                          }    {'PG'         }
{'Phosphatidylinositols'                                          }    {'PI'         }
{'Phosphatidylmethanol'                                           }    {'PMeOH'      }
{'Phosphatidylserines'                                            }    {'PS'         }
{'Sulfatides hexosyl ceramide'                                    }    {'SHexCer'    }
{'Sphingomyelines'                                                }    {'SM'         }
{'Sulfoquinovosyl diacylglycerols'                                }    {'SQDG'       }
{'Triacyl/alkylglycerides'                                        }    {'TG'         }


>> foundpattern

foundpattern =

7×4 table

           ISDs                 tR      Standard desv      RSD  
__________________________    ______    _____________    _______

{'18:1 (d7) MG'          }      1.34       0.020418       1.5238
{'18:1(d7) LPC'          }    1.5868      0.0056024      0.35305
{'18:1 (d9) SM'          }    6.8999        0.08336       1.2081
{'15:0-18:1(d7) PC'      }     7.989       0.072533      0.90791
{'15:0-18:1(d7) DG'      }    12.085       0.097445      0.80631
{'15:0-18:1 (d7)-15:0 TG'}    17.487       0.029701      0.16984
{'Cholesterol (d7)'      }    18.247       0.032275      0.17687

问题在于将 LipidData 的正则表达式PC与 的 foundpattern 值进行比较时{'18:1(d7) LPC'}，会产生“匹配”，但我不知道如何避免这种情况。我只需要在 中找到完全相同的Short值。假设在 found pattern 中有一个，它不仅会与其 LipidData 值匹配，还会与 匹配，foundpattern.ISDs则会出现相同问题的另一个示例。Cer_NSCer_NSCer

我相信将值组合成一个组（使用带括号的正则表达式）是一种解决方案，就像您在代码中看到的那样，但当然这些组是“略微修改的”，因此是重复的。我知道我错过了一些东西，但我不知道是什么。

无论如何都要避免那里的重复匹配？正如您在OUTPUT中看到的那样，Codes 单元格数组应该只有 7 个条目，而不是 8 个。

代码：

Codes={}
for j=1:size(ID,1)
  expression=strcat("(",char(LipidData{j,2}),")");
  for i=1:size(foundpattern,1)
    if regexp(char(foundpattern{i,1}),expression) ~= 0
      disp(foundpattern{i,1})
      disp(LipidData{j,2})
      Codes{end+1}=LipidData{j,2};
    end
  end
end

输出：

>> Codes

Codes =

1×8 cell array

Columns 1 through 6

{1×1 cell}    {1×1 cell}    {1×1 cell}    {1×1 cell}    {1×1 cell}    {1×1 cell}

Columns 7 through 8

{1×1 cell}    {1×1 cell}

>> for i=1:size(Codes,2)
Codes{i}
end

ans =

  1×1 cell array

  {'Cholesterol'}


ans =

  1×1 cell array

  {'DG'}


ans =

  1×1 cell array

  {'LPC'}


ans =

  1×1 cell array

  {'MG'}


ans =

  1×1 cell array

  {'PC'}


ans =

  1×1 cell array

  {'PC'}


ans =

  1×1 cell array

  {'SM'}


ans =

  1×1 cell array

  {'TG'}

>> 

MCVE神栓链接

我有一个概念Trait_AActuallyBTemplate<A,B>来检查是否A= B<...something...>。
它有效。

如何创建一个新概念来检查是否A继承B<...something...>？

#include <vector>
#include <iostream>
namespace hid{
    template <typename T,template<typename... Ty> typename B>
    struct is_mytype : std::false_type { };

    template <typename... A,template<typename... Ty> typename B>
    struct is_mytype<B<A...> ,B> : std::true_type { };

};

template <typename T,template<typename... Ty> typename B>
concept Trait_AActuallyBTemplate = hid::is_mytype<T,B>::value;

//vvv please modify here
template <typename T,template<typename... Ty> typename B>
concept Trait_AInheritFromBTemplate = hid::is_mytype<T,B>::value; 
//^^^ please modify here

int main() {
    static_assert(Trait_AActuallyBTemplate<std::vector<int>,std::vector>,"hehe1");
    static_assert(!Trait_AActuallyBTemplate<int,std::vector>,"hehe2");
    struct MyVector : public std::vector<int> {};
    static_assert(Trait_AInheritFromBTemplate<MyVector,std::vector>,"hehe3"); 
    //^^^ Assert fail only here. (It should pass)  I am sad.
}