相关疑难解决方法(0)

简单的例子.两种方法,一种叫另一种方法:

def method_a(arg):
    some_data = method_b(arg)

def method_b(arg):
    return some_data

在Python中,我们可以def在另一个内部声明def.因此,如果method_b需要并且仅从中调用method_a,我应该method_b在内部声明method_a吗？像这样 :

def method_a(arg):

    def method_b(arg):
        return some_data

    some_data = method_b

或者我应该避免这样做？

除了保存代码行之外,lambda表达式还有什么用处吗？

lambda提供的特殊功能是否解决了不容易解决的问题？我见过的典型用法是代替写这个:

Comparator<Developer> byName = new Comparator<Developer>() {
  @Override
  public int compare(Developer o1, Developer o2) {
    return o1.getName().compareTo(o2.getName());
  }
};

我们可以使用lambda表达式来缩短代码:

Comparator<Developer> byName =
(Developer o1, Developer o2) -> o1.getName().compareTo(o2.getName());

我可以找到很多东西向我展示lambda函数是什么,以及语法如何工作以及什么不是.但除了"酷感因素"(我可以在中间调用另一个函数,整齐!)我还没有看到过于令人信服的事情,说明为什么我真的需要/想要使用它们.

在我见过的大多数例子中,它似乎更像是一种风格或结构选择.并且有点打破了python规则中的"只有一种正确的做法".它如何使我的程序更正确,更可靠,更快速或更容易理解？(我见过的大多数编码标准都倾向于告诉你在单行上避免过于复杂的语句.如果它更容易阅读则将其分解.)

我的代码是:

from Tkinter import *

admin = Tk()
def button(an):
    print an
    print 'het'

b = Button(admin, text='as', command=button('hey'))
b.pack()
mainloop()

按钮不起作用,在没有我的命令的情况下打印'hey'和'het'一次,然后,当我按下按钮时没有任何反应.

Java 8引入了Lambda表达式和Type Annotations.

使用类型注释,可以定义Java注释,如下所示:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE_USE)
public @interface MyTypeAnnotation {
    public String value();
}

然后可以在任何类型引用上使用此注释,例如:

Consumer<String> consumer = new @MyTypeAnnotation("Hello ") Consumer<String>() {
    @Override
    public void accept(String str) {
        System.out.println(str);
    }
};

这是一个完整的例子,它使用这个注释来打印"Hello World":

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.AnnotatedType;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class Java8Example {
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE_USE)
    public @interface MyTypeAnnotation {
        public String value();
    }

    public static void main(String[] args) {
        List<String> list = Arrays.asList("World!", "Type Annotations!"); …

使用一些内置函数,如sorted,sum ...我注意到了它的用法 key=lambda

什么是lambda？它是如何工作的？

还有哪些函数使用key = lambda？

还有其他关键值,比如 key=?

假设我有一个sales时间戳值的DataFrame :

timestamp               sales_office
2014-01-01 09:01:00     Cincinnati
2014-01-01 09:11:00     San Francisco
2014-01-01 15:22:00     Chicago
2014-01-01 19:01:00     Chicago

我想创建一个新列time_hour.我可以通过编写一个简短的函数来创建它,并使用apply()迭代应用它:

def hr_func(ts):
    return ts.hour

sales['time_hour'] = sales['timestamp'].apply(hr_func)

然后我会看到这个结果:

timestamp               sales_office         time_hour
2014-01-01 09:01:00     Cincinnati           9
2014-01-01 09:11:00     San Francisco        9
2014-01-01 15:22:00     Chicago              15
2014-01-01 19:01:00     Chicago              19

什么我想实现的是这样一些较短的转变(我知道是错误的,但在精神得到):

sales['time_hour'] = sales['timestamp'].hour

显然,列是类型的Series,因此没有这些属性,但似乎有一种更简单的方法来使用矩阵运算.

有更直接的方法吗？

问题：

如何在 Pandas 数据框中分别考虑每一行（并可能用 NaN 替换它们），从每一行中删除重复的单元格值？

如果我们可以将所有新创建的 NaN 移到每一行的末尾，那就更好了。

例子：

import pandas as pd
df = pd.DataFrame({'a': ['A', 'A', 'C', 'B'],
                   'b': ['B', 'D', 'B', 'B'],
                   'c': ['C', 'C', 'C', 'A'],
                   'd': ['D', 'D', 'B', 'A']},
                   index=[0, 1, 2, 3])

这创造了这个df：

据了解,Python lambda 函数有助于创建匿名函数.这些可以在排序函数中的map(),reduce(),filter()和key()等其他函数中使用.它还可以用于演示和利用词法闭包.

我想在这里特别了解的是,lambda函数在执行时间方面是否比常规函数具有特定优势,考虑到所有其他因素不变？

由于我是Python的新手,我试图通过类似地将它们与C++的内联函数进行比较来理解它们.正如我从C++中理解的那样,内联函数在节省时间方面很有用,因为它们不需要与函数调用和跳转期间发生的上下文切换有关的必要"内务处理任务".
Python Lambda函数与常规函数相比具有类似的优势吗？

我发现一些相关帖子对我的问题有用但不一定有用: 为什么Python lambdas有用？ 为什么要使用lambda函数？

我正在寻找通过UdpClient课程接收和处理消息的最佳解决方案C#.有没有人有这方面的解决方案？