C# Juval Lowy, кодирующий вопросы о стандартах
Вы можете создать это из самого df. Сначала установите df.index на MultiIndex, используя str.split, а затем unstack и reindex.
df.index = pd.MultiIndex.from_arrays(zip(*df.index.str.split('--')))
(df['value'].unstack()
.reindex(index=df2.index, columns=df2.columns)
.fillna(0, downcast='infer'))
A B C D E
A 4 2 1 0 0
B 0 2 0 0 0
C 0 0 3 0 0
D 0 2 0 0 0
E 0 0 0 0 6
F 0 0 0 0 0
G 0 0 0 0 0
Если вы знаете, какие строки и столбцы вы хотите использовать, вам даже не нужно df2.
(df['value'].unstack()
.reindex(index=list('ABCDEFG'), columns=list('ABCDE'))
.fillna(0, downcast='infer'))
A B C D E
A 4 2 1 0 0
B 0 2 0 0 0
C 0 0 3 0 0
D 0 2 0 0 0
E 0 0 0 0 6
F 0 0 0 0 0
G 0 0 0 0 0
В соответствии с комментарием OP, для поддержания симметрии используйте поворот вашей таблицы, чтобы сохранить NaN, затем fillna с транспонированием:
v = (df['value'].unstack()
.reindex(index=df2.index, columns=df2.columns))
v.fillna(v.T.reindex_like(v)).fillna(0, downcast='infer')
A B C D E
A 4 2 1 0 0
B 2 2 0 2 0
C 1 0 3 0 0
D 0 2 0 0 0
E 0 0 0 0 6
F 0 0 0 0 0
G 0 0 0 0 0
7 ответов
Obviously, I'm not Juval, but I can take a stab at these
1.13 Avoid fully qualified type names. Use the "using" statement instead.
Performance can't be the issue here. I'm sure the issue is readability.
1.26 Use empty parenthesis on parameterless-anonymous methods. Omit the parenthesis only if the anonymous method could have been used on any delegate.
public delegate void Foo1();
public delegate void Foo2(int val);
public void Foo()
{
Foo1 first = delegate { Console.WriteLine("Hello world"); };
Foo2 second = delegate { Console.WriteLine("Hello world"); };
Foo1 third = delegate() { Console.WriteLine("Hello world"); };
Foo2 fourth = delegate() { Console.WriteLine("Hello world"); }; // does not compile
}
Without the parens, the anonymous delegate can be applied to any delegate. With the parens, you're being specific about the signature of the delegate. Prefer the second syntax unless you really need the flexibility.
2.19 Avoid defining custom exception classes
Again, readability is the issue here. The framework exception classes are rich and well-understood. Be wary when replacing them.
2.29 Avoid using the ternary conditional operator
It's a readability and expandability thing. I don't really agree, but it's a standard religious fight.
2.31 Avoid function calls in Boolean conditional statements. Assign into local variables and check on them.
Partially this is readability, and partially it's for ease of debugging. I've starting to assign almost everything to temporary variables just so that they're easily found in the debugger later on.
2.47 Avoid interfaces with one member.
"Avoid" is kinda like "prefer", he's just saying think twice before you do it. If you only have one member, is the interface really modeling something useful and complete in your design? It's pretty rare to have a class with just one member, think seriously about why your interface is any different.
2.53 Prefer using explicit interface implementation
This is similar to the idea of using the least-public accessor you can. If your class doesn't need to make the interface public, then it probably shouldn't. This is going to differ significantly based on your design, obviously, but given the fact that most people just make the interface implicit without really thinking about it, it's advice worth considering.
2.29. Избегайте использования троичного условного оператора. У меня нет проблем с «простым» использованием троичного оператора, но я рекомендовал не использовать его во вложенном виде:
// This is fine
x := (conditionA) ? true_resultA : false_resultA;
// This would probably be clearer using if-then-elseif
x := (conditionA) ?
((conditionA1) ? true_resultA1 : (condition2) ? true_result2 : false_result2) :
((conditionA2) ? true_resultA2 : false_resultA2);
Вот некоторые из моих реакций, на которые я осмелюсь ответить на них:)
1.13 Избегайте полностью определенных имен типов. Вместо этого используйте оператор "using". Я не согласен. Это, конечно, не связано с производительностью. Это может привести к улучшенной читаемости, чтобы иметь var foo = new Foo() вместо var foo = new MyCompany.MyNamespace.Helpers.Xml.Foo(), но кроме этого - нет.
2.19 Избегайте определения пользовательских классов исключений Это бессмыслица imho. Вам следует избегать создания пользовательских исключений, которые являются производными от ApplicationException, но в пользовательских исключениях нет ничего плохого (если вы не собираетесь заново изобретать существующие исключения).
2.29 Избегайте использования троичного условного оператора Я понятия не имею, почему это будет руководящим принципом. Я читал, что не все люди используют его и не могут его распознать, но это не является веской причиной, чтобы не использовать полезный оператор.
2.31 Избегайте вызовов функций в логических условных выражениях. Присвойте локальные переменные и проверьте их. На мой взгляд, это просто проблема читабельности.
2.47 Избегать интерфейсов с одним членом. Я также не согласен здесь. Вы должны избегать интерфейсов «маркер» - интерфейсы без маркера, но которые просто служат для того, чтобы что-то было «... блек» Но один метод интерфейса мне кажется вполне подходящим.
A lot of these guidelines speak to the "quality attributes" of good software design (i.e. maintainability, reliability, reusability, testability, expandability, debugability, interoperability, and what other -ilities you can name).
Often people create code that works fine at the time but may not be the best choice when considering all the quality attributes (in the sense of "where can this software go in the future" or "someone else has to use this code, too").
For example:
2.29 Avoid using the ternary conditional operator
I have no problem with ternary expressions, per se, but by writing code such as: int result = CheckMethod() ? OnTrueDoThis() : OnFalseDoThat()... you are saying, "I have a conditional that, if true (or false), you can do one and only one thing." The whole construct discourages expandability. You have to recreate the construct (with an if..else statement).
Similarly...
2.31 Avoid function calls in Boolean conditional statements. Assign into локальные переменные и проверьте их.
Вы вызвали функцию и по существу «отбросили» результаты для дальнейшего использования. Если эта информация понадобится позже, либо функцию придется вызвать снова, либо структуру кода придется переписать. Это также затруднило бы проверку или регистрацию результатов (для будущей отладки).
Наслаждайтесь,
Роберт С. Картаино
1.26 относится к синтаксису пре-лямбда делегата {} .
// #1 Empty parenthesis on parameterless-anonymous methods would be:
delegate() { }
// #2 ... anonymous method could have been used on any delegate, is:
delegate { }
Помните, что последний может быть назначен любому делегату, независимо от его параметров. Делегат просто игнорирует их, используя некоторые уловки компилятора.
Если вы определяете делегат, не принимающий параметров, явно укажите это с помощью # 1. Не опускайте скобки, потому что ваш делегат в любом случае не принимает никаких параметров.
Это мой лучший удар по перечисленным вами вопросам. Те, о которых я не могу сказать, я пропустил.
1.13 Избегайте полностью определенных имен типов. Вместо этого используйте оператор using.
Читаемость. Когда вам нужно читать полностью определенные имена типов, должно быть сложнее читать код.
2.19 Избегайте определения пользовательских классов исключений
.NET framework поставляется с хорошим набором исключений, встроенных в систему. Если моделируемое вами исключение не является специфическим для бизнес-домена, вы, вероятно, сможете использовать один из существующих классов исключений.
2.29 Избегайте использования тернарного условного оператора
Я думаю, что это наиболее вероятно, потому что он думает, что люди может не понимать оператора, но я не согласен.
2.47 Избегайте взаимодействия с одним членом.
Он мог предупреждать людей о создании слишком тонких интерфейсов. Однако я бы сказал обратное, предупредив людей о том, что интерфейсы должны быть слишком подробными. Если вам когда-либо приходилось иметь дело с ASP.NET MembershipProvider, вы знаете, о чем я говорю.
2.31 Избегайте вызовов функций в логических условных операторах. Назначьте локальным переменным и проверьте их.
Я могу придумать пару причин. Читаемость. Это может затруднить понимание условных операторов, если вы выполняете в них вызовы функций. Кроме того, труднее отлаживать, если вы не наблюдаете.
2.53 Предпочитаю использовать явную реализацию интерфейса
Я считаю, что его рассуждения приведены для краткости. Однако на самом деле я не согласен с этой оценкой. Я думаю, что Джон прав, следует использовать неявный интерфейс, когда это возможно,
Относительно 1.13 (Избегайте полностью определенных имен типов. Вместо этого используйте оператор using):
Это может быть немного больше, чем удобочитаемость. Если у вас слишком много использований в начале файла, у вас есть класс, связанный с классами из слишком большого числа пространств имен.
Класс требует рефакторинга. Использование использования вместо полных имен классов позволяет вам легче идентифицировать такие тесно связанные классы.