FluidMechanics Potential Flows's questions

这是 MRE：

FileAccessPermissions permissions = FileAccessPermissions.Read | FileAccessPermissions.Special;

Console.WriteLine(permissions.ToString("G"));
Console.WriteLine(permissions.ToString("F"));
Console.WriteLine(permissions.ToString("D"));
Console.WriteLine(permissions.ToString("X"));

[Flags]
enum FileAccessPermissions
{
    None = 0,
    Read = 1,
    Write = 2,
    Execute = 4, 
    Delete = 8,
    Special = 16,
    ReadWrite = Read | Write,
}

令我惊讶的是，我找不到一个格式说明符G和F产生不同输出的单一示例。我在这个例子中得到了这个：

Read, Special
Read, Special
17
00000011

如果我这样做： FileAccessPermissions permissions = FileAccessPermissions.ReadWrite; 我会得到：

ReadWrite
ReadWrite
3
00000003

G9我试图了解C# 中格式说明符在处理往返浮点数时的实用性。

简而言之，C#12 一书中提到，这G9有助于避免在将 a 转换float为 astring并转换回 a时出现精度损失float（第 324 页）。但我找不到一个例子来说明G9格式化成功保持相等性，而默认格式化会失败的情况。

例如：

using System;

class Program
{
    static void Main()
    {
        float originalNumber = 0.1f;

        string defaultFormatted = originalNumber.ToString();

        float defaultRoundTrip = float.Parse(defaultFormatted);
        Console.WriteLine("Default Formatting:");
        Console.WriteLine("Original: " + originalNumber);
        Console.WriteLine("Formatted: " + defaultFormatted);
        Console.WriteLine("Round-trip Equal: " + (originalNumber == defaultRoundTrip));

        string g9Formatted = originalNumber.ToString("G9");

        float g9RoundTrip = float.Parse(g9Formatted);
        Console.WriteLine("\nG9 Formatting:");
        Console.WriteLine("Original: " + originalNumber);
        Console.WriteLine("Formatted: " + g9Formatted);
        Console.WriteLine("Round-trip Equal: " + (originalNumber == g9RoundTrip));
    }
}

给我

Default Formatting:
Original: 0.1
Formatted: 0.1
Round-trip Equal: True

G9 Formatting:
Original: 0.1
Formatted: 0.100000001
Round-trip Equal: True

我期待着这样的事情：

Default Formatting:
Original: 0.1
Formatted: 0.100000000001
Round-trip Equal: False

G9 Formatting:
Original: 0.1
Formatted: 0.1
Round-trip Equal: True

我对竞技编程设置中的输入处理相当熟悉，但我无法在 Python 中处理这个问题（https://www.spoj.com/problems/MINDIST/）（我的解决方案在 C++ 中有效，因此问题本身没有问题）。在 SPOJ 平台中读取输入的标准方法是什么？

这里，这就是将输入到标准输入的内容：

输入的第一行包含一个整数 T，表示测试用例的数量。后面跟着 T 个块。

对于每个测试用例，第一行包含两个用空格分隔的整数 N (1<=N<=100000) 和 S (0<=S<=100000000)。接下来的 N-1 行，每行包含三个整数 X (1<=X<=N)、Y (1<=Y<=N) 和 Z (1<=Z<=1000)，表示节点 X 和 Y 之间存在一条 (无向) 加权边 Z。输入是正确的。

联邦输入的一个例子是：

2
5 2
1 2 5
2 3 2
2 4 4
2 5 3
8 6
1 3 2
2 3 2
3 4 6
4 5 3
4 6 4
4 7 2
7 8 3

口粮：

这（仅输入处理）会出现“运行时错误，非零退出代码”（但在本地和在线编译器（如 ideone）上可以工作）：

def get_int():
    return int(input())

def get_ints():
    return map(int, input().split())

T = get_int()
for _ in range(T):
    N, S = get_ints()
    for _ in range(N-1):
        X, Y, Z = get_ints()

看来这个get_ints()调用是个问题，因为：

def get_int():
    return int(input())

def get_ints():
    return map(int, input().split())

T = get_int()
for _ in range(T):
    N, S = 2, 3
    for _ in range(N-1):
        X, Y, Z = 1, 2, 3

得到（正如预期）“错误答案”。

我不知道为什么会发生这种情况。

在《C#12 In A Nutshell》一书中，作者写下了这样的代码：

UnsafeClass a = new UnsafeClass ("Christian Troy");

unsafe struct UnsafeUnicodeString
{
    public short Length;
    public fixed byte Buffer[30];
}

unsafe class UnsafeClass
{
    UnsafeUnicodeString uus;
    public UnsafeClass (string s)
    {
        uus.Length = (short)s.Length;
        fixed (byte* p = uus.Buffer)
            for (int i = 0; i < s.Length; i++)
                p[i] = (byte) s[i];
    }
}

然后他们提到

此示例中还使用了 fixed 关键字，将对象固定在包含缓冲区的堆上（该对象将是 UnsafeClass 的实例）

我不确定我是否理解他们的意思/他们在说什么。如果他们说的是a，为什么a需要固定。如果他们说的是uus，为什么他们会说“将对象固定在堆上”，uus应该在堆栈上，对吗？（仅限值类型）或者也许他们在谈论p？但p如果我理解正确的话，是在堆栈上？

在《C#12 In a Nutshell》（第 259 页，第重载 true 和 false 章）一书中，他们为我们提供了这个例子来说明如何重载 true 和 false 运算符。

SqlBoolean a = SqlBoolean.Null;
if (a)
    Console.WriteLine ("True");
else if (!a)
    Console.WriteLine ("False");
else
    Console.WriteLine ("Null");

public struct SqlBoolean
{
    public static bool operator true (SqlBoolean x)
    {
        return  x.m_value == True.m_value;
    }

    public static bool operator false(SqlBoolean x)
    {
        return x.m_value == False.m_value;
    }

    public static SqlBoolean operator ! (SqlBoolean x)
    {
        if (x.m_value == Null.m_value) return Null;
        if (x.m_value == False.m_value) return True;
        return False;
    }

    public static readonly SqlBoolean Null = new SqlBoolean (0);
    public static readonly SqlBoolean False = new SqlBoolean (1);
    public static readonly SqlBoolean True = new SqlBoolean (2);

    SqlBoolean (byte value) { m_value = value; }
    byte m_value;
}

我试图了解何时false调用过载，并且根据我的理解（并通过使用调试器进行确认），似乎从未调用过过载。false那么为什么过载会有用呢？由于我们只使用while (a)或while (!a)等...过载true和!还不够吗？

这是一个最小的可重现示例：

// Implicit and explicit conversions are overloadable operators:

Note note = new Note (9);
Console.WriteLine(note);

Note n = (Note)554.37;
double x = n;
Console.WriteLine(n);
Console.WriteLine(x);

public struct Note
{
    int value;
    public int SemitonesFromA { get { return value; } }

    public Note (int semitonesFromA) { value = semitonesFromA; }

    // Convert to hertz
    public static implicit operator double (Note x) => 440 * Math.Pow (2, (double)x.value / 12);

    // Convert from hertz (accurate to the nearest semitone)
    public static explicit operator Note (double x) =>
        new Note ((int)(0.5 + 12 * (Math.Log (x / 440) / Math.Log (2)))); 
    
    public override string ToString() => $"{SemitonesFromA} semitones from A";
}

我本以为

9 semitones from A
4 semitones from A
554.3652619537442

但我明白

739.9888454232688
554.3652619537442
554.3652619537442

我认为这是因为在 Console.WriteLine 的“优先级顺序”中，隐式转换为 double 比在 Object 类型上调用 .ToString() 具有更高的优先级。这是如何工作的？如何通过查看文档（https://learn.microsoft.com/en-us/dotnet/api/system.console.writeline?view=net-8.0#overloads）来知道选择了哪些重载？

考虑这个最小可重现的例子。

Point point1 = new Point(1, 2, 3);
Point point2 = new Point(1, 2, 31);

Console.WriteLine(point1 == point2);  // True
Console.WriteLine(point1.Equals(point2));  // True

record Point(double X, double Y, double Z)
{
    public virtual bool Equals(Point other)
    {
        return other != null && X == other.X && Y == other.Y;
    }
}

我是否要用 重写==方法Equals？我似乎也这么做（而且我不仅重写.Equals）。有没有办法只重写其中一个？

如果我使用个人帐户进行克隆，则不起作用。它说找不到存储库。这很有道理，存储库是私人的，而我的个人帐户不在其中。

所以我使用： git clone https://<token>@github.com/.../....git使用我在工作 github 帐户上生成的令牌。

这有效。

现在，如果我进行修改并推送（git add .，git commit -s -m "something"，git push），它可以正常工作，但在存储库中，它显示好像我的个人帐户进行了推送，即使该帐户甚至不属于存储库。我坚持认为，我使用的令牌与该个人帐户无关。

我有点困惑，不知道该怎么办。我认为 git 凭证管理器把事情搞砸了，但我不知道是怎么回事。另外，既然我甚至没有使用我的个人帐户推送该存储库的“权利”，它又是如何工作的呢？令牌是否用于绕过安全性，然后显示的内容甚至不受“控制”？我的意思是，GitHub 是否由于令牌而允许推送事件，但提交本身包含本地 Git 配置中的作者信息，而这些信息可能不匹配？

尽管确认该系列仅包含时间戳对象，但在尝试在 pandas 系列上使用 .dt 访问器时，我遇到了 AttributeError 。我将我的问题浓缩为下面的最小可重现示例（MRE）：

import pandas as pd

# Sample data
data = {'DateGreffe': ['25/10/2023', '26/10/2023', '27/10/2023']}
df = pd.DataFrame(data)

# Convert "DateGreffe" to datetime
df.loc[:, "DateGreffe"] = pd.to_datetime(df["DateGreffe"], dayfirst=True)

# Check data type of "DateGreffe" column
print(df["DateGreffe"].apply(type).unique())

# Convert "DateGreffe" back to string format "DD/MM/YYYY"
df.loc[:, "DateGreffe"] = df["DateGreffe"].dt.strftime("%d/%m/%Y")

print(df)

print 语句的输出确认 DateGreffe 列仅包含 Timestamp 对象。但是，当我尝试在此列上使用 .dt.strftime 时，出现以下错误：

AttributeError：只能将 .dt 访问器与类似日期时间的值一起使用